It’s been awhile since the last test build, but hopefully the new one is worth the wait–thanks to Rob Adams, Snackr v0.38 TEST has an early version of Google Reader integration! If you hook up Snackr to Google Reader, your feed list and read items will be synchronized both ways between the two.

Even if you don’t normally use Google Reader, if you use Snackr on multiple computers (e.g. home and work), it’s handy to sync all of them to Google Reader, so all your feed lists and read items stay in sync across your machines (that’s actually mostly what I use the integration for).

To set up the integration, just go to the Options popup and click on the Google Reader tab, check the checkbox, and enter your Google Reader username and password. You’ll get an option to choose whether you want to use Reader’s feed list or Snackr’s, or merge the two. Once you connect, if you have a lot of feeds in Reader, the ticker might stutter a bit as everything gets synchronized (we hope to improve this in future versions), but after a couple minutes it should clear up.

One important thing to note is that because the feed lists are synchronized, if you delete a feed in Snackr, it will be deleted in Google Reader. We’re hoping to make this optional in the future (so you can choose when deleting a feed in Snackr whether to also delete it in Reader), but for now be aware of this behavior.

Another new feature in this version is a set of helpful tools in the item popup, letting you email the item, post it to del.icio.us/digg, and more. I’m planning to make this extensible in the future, so you can add new tools from the Options popup.

As usual, because this is an early test build, there may be bugs lurking. So:

1. Back up your Snackr database AND your Google Reader feed list first!
   
2. Read the release notes
3. Download the v0.38 build!

And, of course, send us feedback! You can post bugs/feature requests in the issues list, comment here, or send me email. Enjoy!

This version also adds a much-requested feature: the ability to only show items within the last N hours (in previous versions, you could only set this to a number of days). To set this, just go to the Preferences tab of the Options popup, go to “Don’t show items older than”, type the number of hours you want, and choose “hours” instead of “days” from the dropdown.

Finally, this should fix a major bug I introduced in v0.34, where the ticker would permanently freeze after collapsing and re-expanding it in some situations. If you saw this bug before, please let me know if you still see it in this version.

As always, you can leave bug reports/feature requests in comments here, send me email, or file them in the Google Code issue tracker. Thanks!

The first test build, 0.34 TEST, has a few new features and a number of bug fixes. (Sorry, Google Reader integration isn’t in yet, but we’re working on it!) The new features are:

• Implemented ability to “star” items so you can read them later. Click the star icon in the item popup to star an item, then read starred items by clicking the star icon in the ticker tab.
• Added option to configure feed fetch interval globally. This is at the bottom of the Feeds tab in the Options popup. You can also force all feeds to get refreshed here.
• Added option to set transparency of ticker window. This is in the Preferences tab of the Options popup.

The list of bugfixes is detailed in the release notes on the wiki at Google Code. Before installing a test build, you might want to back up your feed database.

If you find any problems, or have thoughts on the new features, please file a bug and note which version you found the bug in. Thanks!

Various people have requested the source code, so I’ve decided to host it on Google Code at http://snackr.googlecode.com/. You can file bugs/enhancement requests on the Issues tab there (the issues and wish list items from snackr.net have been migrated there), and check out the source anonymously using Subversion (instructions are on the Source tab).

The source is currently in an interim state–there are a couple of half-implemented features (the ability to “star” items to read later, and the Google Reader integration that Rob is working on)–but you should be able to run what’s there (the GR stuff isn’t hooked up at all to the UI yet, and the “star” functionality works but the UI is slightly broken). I’m planning to post interim test builds there once in awhile as well.

The source also probably isn’t the prettiest code ever :), and I haven’t finished commenting it, but I’m hoping to continue cleaning it up and refactoring over time. Feel free to check it out, and let me know if you have suggestions–or, better yet, patches you’d like to submit!

After reading through a lot of the tweets and blog posts about Snackr, it seems to me that different people like different things about it. Some people like the design; others like the “up-to-the-minute” feel it gives (somewhat illusory, since it currently only updates each feed every 45 minutes for politeness); others are simply mesmerized by the crawl.

But I think the core of what a lot of people like about it is the same reason I built it originally: the randomness factor. It’s the idea that you don’t have to actually force yourself to keep up with every single thing on every feed, because you don’t have time to do that anyway; you can just sample. It’s very liberating, and it leads you to read items from feeds you don’t normally look at that often.

(Not everybody agrees with this idea; I’ve seen a number of tweets from people saying they didn’t think Snackr would work well if you have a lot of feeds, suggesting that they really want to read everything. In my view, Snackr doesn’t work well unless you have a lot of feeds; if you don’t have much to read, it would just scroll the same stuff by over and over again. But some people do seem to be interested in using it that way.)

Of course, the randomness could be decoupled from the ticker-style presentation; normal blog readers could easily implement a “pick random recent stuff for me” as well (in fact, I’m kind of surprised that popular readers like Google Reader and Bloglines don’t already have this). One of the early tweets about Snackr said “it’s almost what I want: a twhirl-like RSS reader” (twhirl is a popular Twitter client, also built with AIR). I didn’t quite get that at first–wouldn’t that just be like a normal blog reader? But it occurred to me that what he meant was that it would always feel like a mix of new stuff was showing up on top.

That idea, combined with the fact that there are definitely a lot of people turned off by the constant crawl of the ticker (and the lack of ability to control it directly), made me think that it would be worth adding a non-ticker mode to Snackr–a manually-scrollable list of items that would update itself every few minutes. It would still randomly sample feeds the same way the ticker does; it just wouldn’t distract you with constant motion.

This mode would probably be useful for other reasons as well. For example, I’ve started implementing a “star” button on items, so you can mark items you want to keep around to read later. I was originally thinking that when you wanted to read your starred items, Snackr would just switch to showing only starred items in the ticker. But it occurred to me that you might also just want a list of all your starred items that you could manually scroll through. Having a non-ticker mode would fulfill that need.

Anyway, since I have an actual day job (remember Thermo?), I probably won’t get to this immediately. (Not to mention the tons of other great suggestions and bug reports I’ve been getting.) But now that so many people are using it, I have a lot of incentive to keep improving it! Of course, people might tire of it quickly–it’ll be interesting to see how many people are still running Snackr a month down the road.

Now, if I’d only figured out a way to get ads into it…

So, just for grins, I decided to start a Snackr twitter account. Follow snackr on twitter to get up-to-the-minute news about test builds, new releases, and what I’m having for lunch.

Web 2.0-ness aside, I’ve also put up a test build of Snackr, version 0.31, that should properly display non-Western characters, and fixes a couple of other bugs (including adding multi-select in the feed list, so you can delete a bunch of feeds at once). If you read this post, I’d appreciate it if you’d install it and try it out, and let me know if it seems to be working for you.

I’ll probably fix a few more bugs before making a new official build, which will arrive through the standard autoupdate mechanism; if you install this test build manually, you should still get the next official build when I put it up.

• Allow multiple selection in the feed list, so you can delete a bunch of feeds at once. It seems like a lot of people imported large feed lists from their existing blog readers, then realized they didn’t want to actually see all of those feeds in Snackr.
• Support Asian language characters. Currently, Snackr uses Myriad Web, and the font is embedded in order to make fade animations work properly for text, but that font only has Latin characters. I’ll either need to add an option to use the system font (and turn off fade animations), or maybe build a version that embeds a font with Asian characters in it (though that would probably lead to a huge installer).
• Ability to keep a list of items to read later (e.g. by starring them). I’ve been wanting this for awhile but haven’t gotten around to implementing it yet–now I have some incentive!
• Posting the source. I do really want to do this, but I need to set aside some time to make the code slightly less embarrassing

I also noticed today as I was using it on my machine that for some short posts, the popup seems to “bobble around” a bit and end up at a very thin size (it’s different from the jittery animation on Vista/Linux; this is happening even on OS X). It’s intermittent, but it reproduces pretty regularly on certain kinds of posts. Has anybody else seen this? I’ll have to look into it–it must be a recent injection, as I never noticed it before.

I’m planning to make regular updates to Snackr, though things are pretty busy; I’m hoping I can carve out enough time to release a new version in a couple of weeks. Snackr should automatically notify you when an update is available.

Keep those cards and letters coming!

Around the same time I came to this realization, Adobe AIR 1.0 was publicly released. I wanted to try to write an AIR app just for fun, and it occurred to me that I might be able to make something that would solve my RSS problem.

The result is Snackr, a ticker-like widget that lives on the bottom (or side) of your screen and scrolls random items from your RSS feeds. (It’s called “Snackr” because it lets you nibble on your feeds. Guffaw.) Here’s what it looks like on my desktop:

I’m actually finding Snackr really useful—it helps me keep up with blogs I want to keep up with, and also gives me a great smattering of items from sources I wouldn’t normally read regularly. Please try it out and let me know if you like it! (Of course, it’s still an alpha, so please expect bugs; there’s a list of known issues on the Snackr website.)

Snackr has also been really fun to write, and along the way I figured out some tips and tricks for doing various things with Flex and AIR. Some notes on that after the jump.

Snackr is written in Flex 3 (and, of course, AIR). I hadn’t done any AIR development when I started writing it, and it’s a testament to how well AIR is designed that I got the basic thing up and running in a weekend. Of course, most of that was due to my familiarity with Flex, but the fact that AIR makes it trivially easy to package up a normal Flex app as a desktop app is easy to take for granted. With almost no work, I went from being a Flex developer to a cross-platform desktop app developer.

Once I got the basic ticker UI up and running, I started exercising more AIR-specific functionality. Initially, I kept all the feed items in memory, but decided to try out AIR’s local database capability to improve Snackr’s memory footprint. Like a lot of other things in AIR, it was dead easy to set this up; I’m not a database/SQL guru, but it was very straightforward to build out the database code. (I used synchronous mode for simplicity; it would have been much more complex had I tried to do it in asynchronous mode—as with all other Flash/Flex/AJAX programming, asynchronicity is one of the toughest things to manage cleanly, especially if you have a chain of things you want to happen in sequence.)

The next thing I did was build the animation for the popup windows. I ran into a couple of little snags here. I started by trying to just animate the Flex Window component using standard Flex effects, but that didn’t seem to work, probably because setting (say) the x and y of the window component doesn’t actually set the position of the underlying AIR NativeWindow. So, to get it to work correctly, I directly animated the “bounds” property of the underlying AIR NativeWindow class. In order to keep both the position and size of the bounds in sync as I animated, I wrote my own AnimateBounds effect—this was easy to achieve by subclassing TweenEffect and just converting the bounds property of NativeWindow to an array of numbers as TweenEffect expects.

I also had to be careful when drawing the “bubble” background in my popup window’s updateDisplayList() function. Before I added the animation, the background drew fine, but I found that during the animation it didn’t seem to redraw at the right size at each step. I discovered that I had to ignore the standard unscaledWidth/unscaledHeight being passed into updateDisplayList(), and (once again) just look directly at the AIR NativeWindow bounds to get the width and height to use. I’m guessing that during fast animations, the bounds of the Flex Window component don’t update synchronously with the NativeWindow bounds.

Around the time I was finishing up the animation stuff, we released the alpha version of AIR for Linux. Just for grins, I installed Ubuntu in VMWare on my Mac and tried it out—and amazingly enough, it worked! Well, with one snag. As Linux folks know, window transparency is something that’s only recently been supported in Linux, and not all window managers have it. I couldn’t figure out how to get a transparency-supporting window manager set up, so I just punted; the popups look okay without it (though they look like rectangles rather than bubbles).

There was a bigger issue, though. I noticed that unlike on Mac OS X and Windows XP, the popup animation was really jittery on Linux. Later on, when I tried Snackr out on Windows Vista, I noticed some jitter there too (although it’s not nearly as bad as on Linux). I haven’t yet figured out exactly what causes this—I filed a bug with the AIR team—but I’m guessing that on Vista and Linux, even when I set both the position and size of the popup at the same time, the OS either (1) processes them separately, so they get out of sync, or (2) processes the move immediately by directly blitting the window at its current size before I get a chance to redraw it on the resize event. (This mostly comes into play because I’m actually animating the popups upwards, so both the position and size have to change at the same time. It wouldn’t be an issue if you’re just growing a window larger or smaller but keeping it at the same position.)

The final issue, and probably the biggest one, is that there’s no way currently to have Snackr act like a true docking window—it can’t tell the OS to reduce the available space of the desktop, so if you maximize a window, the window will overlap Snackr. There isn’t currently an API for this in AIR, so there’s no real way to work around this for now. To compensate, I’ve added a bunch of convenient ways to get Snackr out of your way; you can toss it around the screen to different sides, put it on a second monitor, or collapse it temporarily.

Other than that, all the functionality I’ve put in Snackr has been really easy to implement. AIR makes it really simple to support multiple monitors, for example. And it’s also pretty easy to implement auto-update—you have to set up whatever logic you want to figure out when a new version is available (e.g. by downloading an XML file from a website), but once you retrieve a newer installer it’s a single function call to run the updater to install it.

I’m planning to put up the source somewhere eventually, but I want to clean it up a bit first (yes, my coding habits are sloppier at home than at work). I definitely plan to continue to add features to it—since I’m using it myself, I have a lot of incentive to keep it up. Also, my colleague Rob Adams (who was the first person to use Snackr besides myself, and has given me lots of great feedback) is planning to add some features to it as well—notably, making it synchronize the feed list and read items with Google Reader, so you can use it as an adjunct to your normal blog reading habits instead of a replacement. (Please feel free to bug him if you want this feature.)

Enjoy Snackr—I’d love to get your feedback!

]]> http://www.rictus.com/muchado/2008/05/12/snackr-an-rss-ticker-built-using-air-and-flex/feed/ http://www.rictus.com/muchado/2008/05/08/best-ui-evar/ http://www.rictus.com/muchado/2008/05/08/best-ui-evar/#comments Thu, 08 May 2008 00:42:47 +0000 nj http://www.rictus.com/muchado/?p=40 From a web application I recently used that shall remain nameless: