If you’re getting close to your service’s free limit, here’s a solution for quickly finding the largest of your files, so you can clean them out or back up elsewhere. This works best when you’ve set up your service to sync everything to your local Mac or Windows computer. In my case I’m using Dropbox which defaults to this mode.

The solution involves a free (open-source) software application, depending on which platform you’re using:

• WinDirStat for Windows
• Disk Inventory X for Mac OS X

The steps are pretty straightforward:

1. Install the utility and start it
2. Point to your local storage path (in my case, the Dropbox home dir)
3. Run the analysis
4. From the results, find the large files and do something with them (back up, move, delete, etc.)

Both utilities show a “treemap” view which helps quickly spot the biggest individual files (e.g., movies), and groups of similar files that collectively take a lot of space (e.g., MP3).

Here are screenshots of the two apps run against my Dropbox path:

WinDirStat results point to the biggest files in my Dropbox account

Disk Inventory X results are patterned after WinDirStat

In my case I’m primarily using Dropbox and have used about half of my 5GB account. I use the WinDirStat utility regularly to find large files that are better saved elsewhere, and to keep my Dropbox backups somewhat manageable.

Here’s a quick look at some numbers since the launch 30 days ago:

• 400 emails delivered with 65% open rate (thank you SendGrid!)
• 15 active users
• 5 inactive users (cancelled)
• 1,700 tweets favorited (from 1,300 separate sources)

So far my “marketing” has included emailing an earlier interest mailing list (about 30), reaching out to some friends individually, and periodic links this blog and my Twitter/LinkedIn accounts.

Next I’ll be asking for specific feedback from each user and continuing with the next couple of features on my to-do list.

If you use Twitter favorites, give Tweetfave a try and let me know what you think!

This project started as one of those “wouldn’t it be useful if…” projects, as an addition to Twitter. I was already using the Twitter favorite feature to bookmark tweets and links to read later, and wanted a way to automatically receive those (short of going to my profile page and viewing my own favorites). Combine that with an interest in learning the Twitter API, and the project was underway.

As I started writing this, I was a bit surprised as to just how long I’ve been working on this. Here’s the history timeline I came up with:

• First working code: April 2011
• Tweetfave.com domain registered: May 2011
• Start keeping source code in git: October 2011
• Landing page, collect email addresses: October 2011
• Feature survey on Amazon Turk: November 2011
• Real front-end live, “coming soon”: October 2012
• First person other than me using it: April 2013
• Go-live, open for anyone to sign up: May 2013

Yes, you read that correctly: I have been working on Tweetfave for two years!

That seems like a long time. I worked on it in chunks of time, and kept using it myself. I favorited over 5000 tweets in that 2-year period, an average of 50/week! In the back of my mind I kept thinking I should finish this and see if anyone else found it useful. A couple months ago I decided to quit procrastinating and finish this to the point where others could give it a try. In April I finally reached that point and asked a few friends to sign up. After a couple more bugs fixed and a week running without errors, I finally opened it up for everyone.

Now I’ve got a few people actively using it and everything seems to be running smoothly. In a few weeks I’ll post some usage numbers and let’s see how much interest I can generate.

If you haven’t tried Tweetfave yet, give it a shot and let me know what you think.

First of all, what does Tweetfave actually do? It periodically checks your Twitter account to look for new tweets you have marked as favorite. If you have any new ones, it sends them to your email inbox. The functionality is very simple, but I’ve found it to be a handy addition to Twitter, turning favorites into a sort of “read it later” bookmarking feature.

Following are some of the software tools and services I used to build Tweetfave:

PHP - for this project I chose PHP because it’s what I’m most proficient in. I’ve got another side project going where I’m learning Ruby on Rails, but for Tweetfave I stuck with the familiar. With PHP’s popularity, everything else I needed was already available as PHP libraries, and it was really easy to set up both my dev and live environments.

Twitter API - learning this API was pretty straightforward, especially with the ease of the PHP library. The trickiest part was setting up the whole OAuth flow with my site’s signup/login flow (and PHP sessions). Originally the code required a read/write access to Twitter accounts, but I later refactored that to use read-only access to minimize the chance of any bugs causing problems for live Twitter accounts. I’ve also switched to the new API version 1.1 without any trouble, and (so far) the application is not running into any rate limit problems.

Twitter PHP Library (by Abraham Williams) - this was the first PHP library to help with Twitter’s OAuth API, and may be the most popular one. It’s very easy to add to a project, and makes calls to Twitter really simple. For example, my main call is getting favorites for an account: $favorites = $twitter->get('favorites/list');. See this discussion for a quick change to support API version 1.1.

Twitter Text PHP Library - the Twitter Text library takes the full text of a tweet and adds hyperlinks and markup for detected identifiers like “@” handles, hyperlinks, and search hashtags. For Tweetfave I use the original tweet text in plain-text emails, and the Twitter Text marked-up version for the HTML email body. The results are pretty decent, making the tweets appear almost the same as on the Twitter website. It also extracts all the links contained in the tweet, making it easy to expand those from short form to their original form.

Mustache Templates & PHP library - Mustache provides a very simple templating language that I use to create all of Tweetfave’s outbound emails. Every email sent has both plain text and rich HTML versions included, and Mustache makes it easy to manage dual templates from the same data source.

Swift Mailer PHP library - creating and sending emails always seems more complicated than it should be. The Swift Mailer library is a straightforward way to ensure your outgoing emails are formatted correctly, especially when you want full control over the email including multipart. Paying attention to the details of email creation also helps prevent the messages from being flagged as spam.

SendGrid † - a very reliable email delivery service that “just works”. Even when I was on the free plan, I made a couple of support requests and had excellent service both times. I really like SendGrid’s reports and “Email Activity” dashboard, both of which make troubleshooting and tracking a breeze. One downside is you don’t get a dedicated IP address for your delivery point unless you’re at the $79/month pricing level. So far my emails seem to avoid being flagged as spam even without the dedicated IP.

Bootstrap - the Tweetfave website consists of only a couple of pages, but I wanted to make sure they worked well on both desktop and mobile browsers, so I used Bootstrap as a starting point. It was pretty easy to learn LESS and tailor the Bootstrap template down to just what I needed. For the next go-round, I need to learn how to customize Bootstrap while still being able to merge updates and improvements.

pair Networks † - I’ve been using them for web hosting for over 10 years for this blog and a few small side projects. I ran Tweetfave here as well during the year-long development. Recently as Tweetfave usage has grown, my cron scripts are a bit too much for my shared webhost account, so I moved them to Digital Ocean. I kept the MySQL backend and website on pair.

Digital Ocean - after I outgrew my shared webhost, I signed up for a basic VPS ($5/mo) from Digital Ocean. Signing up and creating my virst VPS (a “droplet” in their terminology”) only took about 15 minutes. Installing my code and packages like PHP only took about a half hour. Very impressed so far.

† Affiliate link; I’ll earn a small referral fee if you use this link; thanks for supporting this service!

I’m happy to answer any questions about the software and services used to build Tweetfave. Just shoot me an email (brian at cantoni dot org).

If you haven’t tried Tweetfave yet, give it a shot.

Image credit: zzpza (Flickr)

Tweetfave is a free service to help you get more out of Twitter favorites. Tweetfave monitors your Twitter feed and sends the tweets you mark as favorite to your inbox.

I built Tweetfave for myself (“scratching my own itch”) and it’s really helped me track and remember interesting tweets and links. It’s especially useful when reading my Twitter feed on a mobile phone. If I don’t have the time (or patience) to read linked articles on the phone, I’ll mark the tweet as a favorite, knowing it will arrive later in my inbox.

Give Tweetfave a try and let me know if you find it useful, and whether it changes any of your Twitter favoriting behavior. (In my case I have favorited over 5000 tweets since I started working on this project. I’ll save the details for another post…)

Tweetfave sends the tweets you marked as favorite to your inbox

As of today (2 more domains registered!) I have 17 domain names, 7 of which have live websites. The rest are on my “todo” project list.

I’ve been very happy with pair, both on price and support.

If you have a need for either web hosting or domain name registration, you should consider pair. If you use these links I’ll get a small referral which helps pay the bills.

• Web hosting by pair Networks.
• Domain Name Registered by pairNIC.

Twitter friend data loaded in Excel

This script is written in PHP and uses the Twitter OAuth PHP library. It uses the Twitter API methods friends/ids and users/lookup. Because the user lookup can handle up to 100 friends at a time, these APIs are quite efficient.

This script is available on GitHub (bcantoni/5457114), and embedded below. Follow the installation steps if you want to try it yourself.

I’ve been seeing this more frequently lately with email newsletters. The most common cause is link tracking added by the newsletter delivery vendor (MailChimp, Tinyletter, etc.). The scam warning will come up whenever the displayed text link does not match the embedded hyperlink. It’s mean to detect phishing attacks where the displayed text may say “paypal.com”, but the link actually goes to “evilsite.com”.

For example, this link will cause the warning:

<p>Visit our home page: <a href="http://mailchimp.com/track/xyz...">http://example.com</a></p>

Instead the problem can be avoided by using text instead of a URL for the link:

<p>Visit our <a href="http://mailchimp.com/track/xyz...">home page</a></p>

Here’s an example of Thunderbird complaining about a few links in Scott Hanselman’s Newsletter of Wonderful Things. (By the way I don’t mean to pick on this excellent newsletter, just using it as an example.)

An example of the Email Scam warning message in the Thunderbird email client

To learn more, I recommend these two resources which explain the Thunderbird behavior and how to prevent it for most cases:

• From Mozilla, an explanation of Thunderbird’s Scam Detection
• From MailChimp, how to avoid possible fraud alerts

When I first started listening to podcasts on my first MP3 player (a Creative Zen Touch), the software was very basic. I was tracking my podcast RSS feeds in Bloglines, so I wrote a Bloglines enclosure download script which I would run periodically on my Windows desktop, then use Windows Media Player to bulk copy everything to the Zen Touch.

For today’s iPhone users, there’s no excuse to not have a great podcast player. You’ve got the network connectivity, the audio player, and plenty of storage. Apple’s own Podcast application leaves a lot to be desired. It provides only basic functionality and doesn’t seem to ever be improved upon by Apple. Just check this Google search for Apple Podcast App - the top 5 results tell the story:

Searching for “Apple Podcast App” shows some unflattering results

Instead, I recommend buying Downcast (US $1.99). I’ve recently switched and have my dozen or so tech podcasts up and running:

Screenshot of Downcast main screen with several podcasts loaded and ready

What makes Downcast so great? This is my short list of favorite features:

• Automatic refresh & downloads. Configurable to only download over wi-fi.
• Skip forward & backward by remote control commands (the “now playing” view), or by shaking the phone.
• Adjustable playback speed (1.5X, 2X, etc.). I’ve set this to 1.5X for most podcasts and it’s very listenable without making everyone’s voices sound funny.
• Settings galore. Possibly more than an iPhone aficionado would like to see, but I like the detailed level of control. In addition to global settings, you also have settings for individual podcasts (like the playback speed).
• Export feeds to OPML. Useful for backing up your current subscription list, and if you want to follow along with an RSS reader.

I have not played with everything yet, including iCloud Sync which is supposed to help when listening over multiple devices.

Finally, I have one feature suggestion: an option to email the “show notes” from each podcast episode you’ve listened to. It could be pretty simple to add, and would really make the whole flow of listening to podcasts much better. I don’t know of any podcast or similar app that does this, so to the maker’s of Downcast, here’s your chance!

Lynx

Lynx is an open-source text web browser that is usually present on Linux machines and can be installed for Mac and Windows. I’ve used it in the past to see how web pages will appear to search engines or for accessibility testing. In both cases, you can quickly tell whether your text is sufficiently communicating your content.

For the case of saving web pages in text format, Lynx also has a command-line option “-dump”:

$ lynx -dump http://www.whatismyip.com/ > example.txt

In my test case I couldn’t convince Lynx to fetch an SSL page, so I download it with Curl and pipe it into Lynx:

$ curl --silent https://developer.citrixonline.com/api/gotomeeting-rest-api/apimethod/get-meetings | lynx -dump -stdin > lynx.txt

URL

   https://api.citrixonline.com/G2M/rest/meetings

Method

   GET

Response Type

   JSON

Parameters

   scheduled A string "true" to get all future meetings.

   history A string "true" to get past meetings within date range.

   startDate If history=true, required start of date range, in ISO8601 UTC
   format.

   endDate If history=true, required end of date range, in ISO8601 UTC
   format.

Pandoc

Pandoc is an open-source “universal document converter” which understands (and can convert between) about two dozen different formats. It’s well suited for writing a document in a primary source, then converting to other formats for different publishing options.

The option we’ll use here is Pandoc’s ability to convert from HTML to Markdown, for example:

$ pandoc -s -r html http://www.whatismyip.com/ -o pandoc.md

For my page, I use the same trick as above because Pandoc can’t connect to SSL directly:

$ curl --silent https://developer.citrixonline.com/api/gotomeeting-rest-api/apimethod/get-meetings | pandoc -s -r html -o pandoc.md

And here’s the sample output of the same section as above:

### URL

https://api.citrixonline.com/G2M/rest/meetings

### Method

GET

### Response Type

JSON

### Parameters

**scheduled** A string "true" to get all future meetings.

**history** A string "true" to get past meetings within date range.

**startDate** If history=true, required start of date range, in ISO8601
UTC format.

**endDate** If history=true, required end of date range, in ISO8601 UTC
format.

Conclusion

Both of these options do a pretty decent job of converting HTML into text or Markdown format. Pandoc seems slightly better in terms of getting to Markdown format, but I would need to run some more samples to see how much manual editing would be needed after.

I’m also going to play a bit more with Aaron Schwartz’s Html2Text. In my quick test, it appeared to have a problem with malformed HTML so I need to do some further testing with it.