Quite a while ago (like, in at least 2009), I started thinking about regaining control of all the content I was producing online. I was posting photos to Flickr, saving bookmarks to Delicious. I started Tweeting. I was checking in. All fun and games, and all of those services offer great tools for interacting with them (let’s face it, tools that are much better than WordPress’, because they are focussed on one thing). So I figured, why not write importers for these services and pull my content back over to my WordPress. And keep doing it periodically, so that I could keep using those tools. I want WordPress to be my “home on the web”, my digital hub, but I want to use these neat tools with their fancy apps and what-have-you.

Very quickly, I realized that if I was going to do anything useful on most web services, I’d need to be able to authenticate with them. No biggie, right? I know my username and password… Oh. Right. OAuth. Turns out that most web services use OAuth (or something similar) to authenticate, and it turns out that that’s actually a bit of a bear to implement, when all you want to do is write a simple little Twitter importer. And then again for a Foursquare importer. And a Flickr importer.

What I needed was a shared, generic authentication framework that would do all the heavy lifting for me. I would tell it I wanted a connection to specific service, and if it didn’t have one, it’d walk the user through the process of getting one. It’d give me a standardized format of authentication credentials and abstract out all the complexity of making authenticated requests against those services. Then it would make me a coffee*. What I needed, was Keyring.

And so Keyring was born. Basically it’s a bunch of code that’ll handle external authentication with a web service so you don’t have to. It’ll store tokens/passwords/whatever, can talk to all kinds of different services, and is really, really extendable. It also has hooks. Lots of them. So if you want to do something custom, you probably can. It’s intended to be a foundation for writing other plugins, and really doesn’t do much interesting on its own.

I already have importers written for Twitter, Delicious and Foursquare which are based on Keyring and so far they’re working pretty nicely. There’s a lot of work to go on this project though. For Keyring to be a truly powerful framework, I need to:

• Drastically improve the UI, which is a hodge-podge of hideousness at the moment
• Improve a few parts of the Core UX which are pretty clunky right now
• Put in some more failsafes/helpers for making sure things are up and running before allowing plugins to use Keyring
• Improve internal security
• Tighten up Permissions/Roles restrictions all over the place
• Handle multi-user blogs (especially around token storage)
• Work on Multi-Site
• Support more services (preferences? suggestions?)
• Figure out a good way of allowing people to drop in their own Service extensions (and not overwrite them with updates)
• Improve the handling of auth flows in other plugins, and preferably move as much of that logic as possible into Keyring Core

I’m slowly working on this, but it’s all kind of a personal project at this point, so it’s just a few hours here and there. My main goal is to get it functioning so that I can get my content back. Once that’s done, then I’ll spend more time tightening it up for other/platform use. I also have a couple of other “companion plugins” that I’m working on — auto-linking text for Twitter @mentions and #hashtags, mining posts and downloading remote media (e.g. Instagram images) and some stuff around geo for mapping things like Tweets and Foursquare checkins (all the geo-data is imported in the importers I wrote).

Next on the list is abstracting and then releasing the importers that I have. That will give people something more tangible to use as an example. After that I’ll be working on a Flickr importer, but that’s a pretty big project in and of itself.

So, what do you think? Useful? Waste of time? Massive, gaping, horrendous holes? LMK (in the comments) and we’ll see what we can do.

And you know the drill — patches welcome

* Sadly, Keyring will not make you coffee. Yet.

It feels like every time I walk around in San Francisco (and other places), I see all this cool artwork, quotes, stencils etc on the sidewalk that I’m sure a lot of people are missing or not appreciating. SidewalkScribbl.es will be a place to share those things. The site will most likely get a facelift to make things look better, but in the meantime I’m just getting started with some of the things I’ve already collected from around the place.

Keep an eye out for another *Scribbl.es site soon

Jetpack is a new plugin that delivers a bunch of popular features from WordPress.com (the hosted site, which Automattic runs) to self-hosted installs of WordPress (such as the one that runs Dented Reality). Once you install Jetpack, you get some of the cooler things available on WordPress.com, automatically enabled on your own WordPress site. The modules you get today are just the beginning though, there are a lot more planned for future releases. We’re going to be targeting some of the biggest features that are easier for us to do on our massive grid/cloud infrastructure, but harder for folks to do on their own shared-hosting accounts.

We also managed to partner with a bunch of leading web hosts, so if you’re doing a one-click install on Bluehost, DreamHost, Go Daddy, HostGator, Media Temple, or Network Solutions, you’ll get Jetpack as part of your install. This is huge for people installing their own WordPress.

This has been the coolest thing I’ve worked on at Automattic so far, and it’s been awesome to be involved in a project that has seen so many contributions internally (over 40 people were involved in everything from UX to design to internationalization to testing and debugging) and so many iterations since its inception. I’m really proud of what we’ve created, and hope that it sets a new bar for the design of WordPress plugins (I really think Jetpack is beautiful, amazing work Joen, Hugo and MT!).

So – check out Jetpack if you’re running WordPress on your own server, and let us know what you think!

Which features would you most like to see in Jetpack? Let me know in the comments and I’ll see what I can do

PS: This post proudly proof-read by After The Deadline, as delivered via Jetpack

That project is available for download now, under the name ListML. Check it out, I use it all the time, so will probably continue developing it. At the moment it’s just a simple script that you drop into a directory, then drop other TXT files in there to view them as HTML. We’ll see where it ends up. If you’ve got any suggestions or find any bugs, feel free to post them as a comment here and I’ll fix things up. I already have some ideas on new features:

• Ability to load external files (from URL)
• List files in the current directory if none specified
• Cut out the parsing engine properly to make it more portable
• Make the HTML view (optionally) into a lightweight editor as well
• Quick UI for grabbing the HTML snippet of just the list (sans CSS/extras)

Please grab a copy, try it out and let me know what you think. It hasn’t actually been used for anything useful yet, so I’m also interested to hear what you’re using it for!

The project was to create a web service that would scrape URLs and pull out any content marked up in hCard content (e.g. my contact page) and would then load that content into an LDAP directory. The reason for this is that most Address Book/Contact applications can plug into an LDAP directory to populate their details, so this would provide a direct pipe between client-side contact storage and web-based, decentralized information. The web service would periodically check the URLs it knew about for updates and update LDAP appropriately. If people update their hCard-based information, the LDAP directory would automatically pick up that change and update itself. I’ve talked about this idea before.

Building (or even tinkering with) this system required that we learned about LDAP, and as it turned out, none of us knew much more than the very basic concepts involved with LDAP, so we had a lot of learning to do. I’m putting together a list of LDAP basics that I’ll publish once they’re straightened out a bit. In the meantime, a specifically big thank you to Tantek for organizing ufDevCamp, to Stephen Weber for working with me on the LDAP/code side of things (and showing me how to get started on github.com, and to Mark Ng for setting up an OpenLDAP server for us to play with, and for helping figure out some of the configuration options etc required to get it all working.

Oh, and there’s some code over here if you’re interested, and we made a page on the microformats wiki with some info on our progress.

Check out the KRead project page for some more details or jump over to http://kread.dentedreality.com.au/ and try it out.

Automattic built the wonderful Prologue theme for WordPress which turns it into a private Twitter. Coming soon is Prologue Projects, a powerful yet lightweight project-management/monitoring version of the Prologue theme. Wouldn’t it be wonderful if you could use existing Twitter-tools on a system using one of these themes? Let’s do that.

It seems like it wouldn’t really be all that big of a task to write a layer (implemented as a plugin and/or theme) for WordPress which walked and talked like the Twitter API, but on the backend, interfaced with WordPress. Then you’d just point your Twitter tools (which support specifying a different URL) to your WordPress install and you’re off and running. I could see it supporting the core functionality relatively easily:

• Public Timeline
• Friends Timeline (if you added the concept of friends, not that hard)
• User Timeline
• Show
• Update
• Replies — perhaps showing comments?
• Update

And what about the Search API? No problem. WordPress has a search system (although it could use some work). In fact most of this functionality would be easily achieved through a custom theme with a little bit of intelligence baked in so that it could output its data in different formats (JSON, Atom, etc) and intercept requests at certain URLs.

The big question is – what’s the point? Well… I dunno… it’d be kinda cool? Apart from being cool – this could also be a very powerful internal business tool, we’ll see where it all goes.

As it turns out, it’s been quite a project. LiveJournal’s API is, shall we say, “challenging” to work with, and the sheer size of Guav’s journal (over 3,700 posts and nearly 200,000 comments) meant that I kept running into time, memory and database limits that would crash the importer. After a lot of back and forth with Guav though, I’m happy to present the new importer (find it under Tools > Import > LiveJournal), sporting the following features:

• Just enter your LiveJournal username and password and you’re ready to go
• Via the API, it connects directly to LiveJournal and imports all of your posts,
  • Posts marked as “Friends Only” are assigned a password within WordPress,
  • Posts marked as “Private (you only)” are marked as Private within WordPress, which means that only authors on your new blog can read them,
  • lj-cut tags are converted to the WordPress equivalent, the <! — more — > tag,
  • lj-user tags are converted to normal links, and have class=”lj-user” attached to them to make it easier to style them if you like,
  • Tags are imported properly,
  • If you closed the comments on a post in LiveJournal, then they’ll be closed in WordPress as well,
  • Lots of the “meta” information related to posts is also imported using WordPress’ Custom Fields feature. You could then use these values to reproduce some of LiveJournal’s functionality within your new theme if you like. The fields imported are:
    • If your post contains adult content (lj_adult_content),
    • Your current co-ordinates and location (lj_current_coords and lj_current_location),
    • Your current mood (lj_current_mood),
    • Current music (lj_current_music),
    • Your userpic keyword (lj_picture_keyword)
• Next up, all of your comments are also imported,
  • Threading is preserved, so replies to other comments show up successfully (provided you enable that feature in WordPress),
  • The “subject” of each comment is included as the first line of the comment itself, because WordPress doesn’t have a comment title/subject value,
  • LiveJournal users get links back to their LiveJournals,
  • Your own comments are linked to your WordPress account, and are linked back to your new WordPress blog,
  • Anonymous users are labeled as “Anonymous”,
  • “Screened” comments on LiveJournal are imported as “Unapproved” within WordPress, so you can decide what to do with them

So there you have it, a brand new, shiny LiveJournal importer. This should be bundled with the 2.8 release of WordPress (it’s available right now on WordPress.com), and will be available for everyone. As I mentioned, it’s been tested with one single, very large blog (and a few smaller test ones), but if you find anything wrong with it, please file a bug on the WordPress Trac!

Huge thanks again to Guav for helping with the testing of this thing (maybe now he can migrate over to WordPress as well)!

Custom icons for a WordPress feed, and a Twitter search.

This version also supports Atom feeds (in addition to previous RSS 2.0 support).

Check out the latest FeedGrowler.

Check out FeedGrowler’s project page »

• TwitterProxy: Which allows you to do some cool filtering on your Twitter status feed (and then use it for whatever you want), and
• Gravatar Shortcode: A quick WordPress plugin that gives you a shortcode that you can use to inject a Gravatar into your Pages or Posts.

Check them out and let me know what you think.

Basically what they’ve done is extracted all the color-based information from the admin CSS files, and put them into pluggable files called “Admin Color Schemes”. The cool bit is that it looks really easy to add your own! It looks like the Admin Color Scheme is one of the last (core) stylesheets loaded into a page as well, which means you’re really not limited to only changing the colors.

So how do you do it? Here we go:

1. Download this plugin: WP Admin Color Schemer 1.0
2. Install and enable the plugin, which will look for CSS files inside its own “/schemes/” directory (/wp-content/plugins/wp-admin-color-schemer/schemes/*.css).
3. Create your own CSS file and drop it in that directory. The filename of the CSS file should be a lower-case, letters/numbers only, dash-separated version of the name of the scheme. For example, a scheme called “Billy’s Amazing Scheme” would be in a file named “billy-s-amazing-scheme.css” (replace everything that isn’t a letter or a number with a dash, but only ever have a single dash at a time). Make sure the first line looks like this (with “My Admin Scheme” being the name you want to give your scheme, and each hex value representing one of the main colors used in your CSS palette. This must be the first line of the CSS file, be commented out as below, and must contain commas, but the spaces are optional):

/* My Admin Scheme, #000000, #111111, #222222, #333333 */

Once you’ve done that, go to your profile page within the Admin Panel, and you’ll see your new scheme and should be able to easily select it. When you hit the Update button, your Admin Panel should take on the new colors immediately.

If you’d like to use one of the built-in Admin Color Schemes as a starting point, then they live at /wp-admin/css/colors-classic.css and colors-fresh.css.

Now you can easily style your Admin Panel to match the rest of your site (and hopefully Theme authors out there will start packaging Admin Color Schemes to match their Themes).

I suppose imitation is the greatest form of flattery right? So we should take this as a compliment?

In amongst some work that I’ve been doing recently, and looking at my own work habits and trends, I realized that something super-useful to have would be a very accessible “microcontent storage system” where you would be able to store small snippets of information, tag them, have them fully-indexed and searchable using a simple, slick interface. Basically, I’m seeing this as del.icio.us, with more space for storing text, and no requirement for a link.

General Idea

So I see this as a series of “items”, stored with a note/body item of some sort, which would normally be text. In addition to that, you’d have an optional title and link/URL. You’d have a list of tags/keywords, and perhaps allow for arbitrary meta-data. I like the idea of the meta-data because it makes the system simple, yes extensible in ways that simple tags don’t provide (easily).

The UI would probably be largely based around search (a la Google), and would provide a list of items recently added as the default result-set. When searching, we’d probably use AJAX to make it “live search” to aid progressive discovery. I’d like to be able to save a search as well, and have that available as a navigation item of some sort (e.g. All items tagged “work” and “urgent” but note “done”). Adding an item should be a matter of clicking a link, then typing a few items and hitting a button. You’d also want a bookmarklet to be available so you could do this from anywhere. Perhaps even a Firefox plugin a la the del.icio.us one.

I’d also want RSS feeds available, specifically “recent items added” and “all items tagged x”.

Privacy controls, the ability to share items (or tags) and some other things like that would come down the line. I’d specifically like to be able to invite people to access my stream, and grant them the ability to see only items tagged with certain tags.

From here, we would also want a robust API so that we could plug the system in as the storage/backend behind any number of other apps. I see the use of POST to create new items, GET being able to retrieve a simple XML description of an item, PUT updating existing ones, and DELETE removing one. Standard REST stuff. The interesting thing here is that there’s no real reason why you couldn’t do it all with namespaced RSS (2.0) or Atom. I think that’d be a good approach because the basic structure is there, you just need to add some meta-data options which is no real problem.

The API is where the real fun lies – this could be the Twitter of… everything else. I see it as a generalized micro-content publishing system. Two immediate things that I think would be fun to plug on top of it (perhaps as paid services?) would be an email reader and an RSS reader. Basically these 2 systems would periodically check email/RSS feeds, then parse new items, tag them (using existing tags or some style of content analysis) and then POST the new item to your Stanso stream. It’d be interesting to see your email, notes, RSS feeds and potentially other things all mixed in together, tagged using a common scheme etc. Who knows where it could go? This could be a todo list, an email client, a news reader, a blogging platform, a status system, a bookmark repository, a password storage tool, a file manager, or all sorts of other things.

Technology Options

Obviously this could be built very simply using something like Scuttle (del.icio.us clone), or just from scratch using the normal LAMP stack (or RoR, or whatever). Another option I’ve been pondering is Amazon Web Services. Of particular interest are SimpleDB (still in beta, waiting on the list…) and potentially S3.

SimpleDB allows you to store a very loosely-structured set of data around a “record” in a fast-lookup, easily-queryable environment. Seems perfect for the task. It could handle arbitrary meta-data per item if you wanted, and could handle unlimited tags per item easily as well. I think S3 could be an interesting addition if you added the ability to upload a file (with tags etc), which was sidelined into S3, then automatically linked (via the URL field in an item) into your Stanso stream.

Another possibility would be to use something like WordPress to build this, since it actually handles a lot of elements of the system already (post title, body, tags, meta-data, the general blogging/posting flow). Having worked with WordPress a lot in the last 6 months though, I’d have to think that it was overkill for this, and provides a lot of other (wasted) functionality that provides more overhead than is worth adopting. Probably taking something like Scuttle and modifying it would be a best bet for a prototype at least. If building on AWS then you’d have to get pretty custom.

Possible Implementations/Features

• Simple note storage — you post small notes and snippets to remind you of things, or to hang on to passwords etc so you can find them later.
• Feed reader — feeds come in, are tagged and added to your stream, you navigate by tag or by “recentness”.
• Email client — email is pulled in and automatically tagged based on content analysis, sender details, etc. Being able to add your own tags would be awesome.
• Todo list — post items that you need to do, tagging them as “not done” perhaps. When they are done, you remove that tag (or just delete the item).
• Micro-blogging — post small updates on what you’re doing, what you’re thinking etc, then publish it out from the system via the “recent” RSS feed
• Bookmark storage — as per del.icio.us, minus all the social stuff.
• File manager — with file uploads going to S3, and meta stored in Stanso, you could store things in any “structure” (via tags) you wanted.

The cool thing is that you could actually do a number of these (if not all) at once, since you would have the ability to segment out your storage/retrieval of items based on tags as well.

Of course, after I started writing all of this, I realized it was just a slimmed down version of HTFS… so yes, I really should be building that system

The idea of the site is to give parents and families a secure place online where they can compile a journal of memories for their children. We’re focusing primarily on photos right now, but hope to include video and audio as we progress. Here’s a couple of the things that I think make MyBaby unique or worth a look:

• Unlimited uploads (backed by Amazon S3)
• You choose to have your book open to the public (for reading), or completely invite-only.
• Once they join your book via invitation, other people can add their own photos and stories to your book as well
• We have some really beautiful book themes (and more coming) care of Ray Hernandez/Stoodio
• We’ve created a forum on the site as well to allow people to interact across books (anyone who’s a member can post) and ask each other questions etc.
• You can try it out for free!

Right now, people get 3 weeks to try it out for free, after that, if they like it, it’s $8 a month to continue using the service. This covers you for as much as you (and all the members of your book) want to upload. You can pay for more than a month at a time and get a discount as well. We’re trying out a slightly different method of payment where subscriptions aren’t actually available in a traditional set-your-details-and-forget way. What we’re doing is allowing anyone who’s a member of the book to contribute by paying for as much (or as little) as they like. We’re hoping that rather than the parent having to pay every month, other people in the family will chip in and cover the cost of keeping the book running if they see value in it.

Ray and I are really excited now that it’s live, and very nervous to see where it goes. We’ve spent a lot of time working on this and refining things, so it’s great to finally have some other people using it.

Now for the real work — keeping it up and running and constantly improving it for our new users!

This version supports titles (so everyone can stop asking now!) and I improved some of the messages a little as well. There is also a new feature which allows you to specify the size of the edit fields so that you can maximize the use of your device’s screen-size.

To specify a custom size, add ?w=XX&h=YY to the end of the URL in AvantGo (or your handheld’s bookmark), where XX is the width of the main post body (and title field) and YY is the height. These values should be somewhere in the range of 10 – 30 each. You will need to play around to see what’s right for your device, but as a hint; my old Palm Vx used 17 and 6, my HP iPAQ uses 20 and 11 to get the biggest space available.

Happy Posting!

PS: For those who are interested, I’m also putting together a new ‘AvantType’ that will operate exactly as AvantBlog does, but post to a TypePad blog!

I’m writing this very post in webpad, and I think this is by far the best release of the program, with some cool new features, much better stability, and compatibility with more browsers than ever. Jump on over to the webpad Project Page to see what all the fuss is about, or you can just go ahead and download webpad now.

I’m expecting to release webpad next week, if not this weekend!