About Colette Patterns

From the Colette Patterns about page:

Colette Patterns’ mission is to help you create clothing that feels both beautiful and personal. While it’s all too easy to find cheap, cute, disposable clothing meant to be worn for weeks or months and then discarded, making your own clothing is an entirely different experience. It’s something cherished, something chosen, something entirely you.

About the project

In order to easily incorporate the blog on the old Colette Patterns site, this site was built entirely on Wordpress. Working from the designs provided, I created a Wordpress theme from scratch and integrated the Shopp ecommerce plugin to run the store. Customers are given the choice of buying via Paypal or a secure on-site checkout using Authorize.net.

Shopp is a great choice for anyone needing to add ecommerce onto a Wordpress site. I chose it over the other options in this area due to the well designed API and clearly written documentation. The store pages are heavily modified versions of the Shopp defaults.

The front end is valid XHTML and CSS, except in a couple spots where invalid markup is generated by backend plugins. All JavaScript on the site was written using jQuery.

Our mission is to facilitate charitable and philanthropic endeavors, increase public participation in initiatives to do good, and maximize the public benefits for those most in need.

To accomplish this we’ve developed doGoodr: A web site and suite of Internet-enabled tools that allow anyone with a legitimate need and anyone wishing to offer them assistance, to find each other in the fastest, most efficient way possible.

If you have a cause or project that you need help with — anything from large-scale natural disaster relief to a local “save the soccer field” campaign — you can post it to doGoodr along with details on what you’re doing, who you’re helping, and the resources you need to do it. Likewise, if you’re looking to get involved in a charitable cause by donating time, money, or anything else, you can use the site to find projects that suit your interests.

The doGoodr Fund is a registered 501(c)(3) nonprofit California public benefit corporation.

About the project

This project includes two web sites, doGoodr and the companion doGoodr Fund informational site. Both are based on Ruby on Rails.

I am the sole front-end developer on the project and wrote around 99% of the HTML and CSS, as well as some supporting JavaScript, Rails view code, and controller logic. The team consists of myself, three other developers focusing on JavaScript and the Rails backend, and the founder of the project who also did the design work. The work has progressed through numerous design iterations to reach this stage and development is continuing post-launch, with an overhaul of some of the key interaction planned as well as continuous refinement.

I also serve in a general technical advisory role, helping to make decisions regarding various technologies and techniques used for the site, and as a standards and usability advocate.

How you can help

Get involved! Our launch last week was a “soft launch” with no public fanfare. This is the kind of project that increases in value as more people use it, so if you’ve got any sort of dream project, post it! Use of the site is free and you just may find the help you need.

Upon review, there’s very little that’s Wordpress-specific about it — it’s aware of WP theme locations but that’s really it. So I figured it would be more useful, both to myself and to others, as a general-purpose PHP library instead of just a Wordpress plugin. So I’ve just released Asset Helper 1.1 which removes the Wordpress requirement.

To use it on a non-Wordpress site, just place asset-helper.php somewhere your site can access it and include it before your site’s code begins:

<?php include_once 'asset-helper.php'; ?>

It still works with Wordpress, of course, either as an external library as shown here or as a standard plugin. The plugin interface is recommended for WP sites, as this will let you take advantage of the update notifications, but it works either way.

Read my Asset Helper overview for general information and the function reference for more details and an implementation guide.

Download Asset Helper from the Wordpress plugin directory

One optimization that’s becoming more popular lately is the use of far-future expires headers for static files on your site. With a bit of web server configuration, you can instruct browsers to cache your images, stylesheets, JavaScript, and any other static files for as long as you wish, which results in faster page load times after the initial visit because the browsers won’t try to download new copies of these files. This can make a dramatic difference in load times for large, high-traffic sites but can also benefit smaller sites.

For Apache, this configuration might look something like this:

ExpiresActive On
<FilesMatch "\.(ico|gif|jpe?g|png|js|css)$">
	ExpiresDefault "access plus 1 year"
</FilesMatch>

The one disadvantage to this practice is that sometimes these files change and you want your readers to get the latest versions. This is particularly the case with CSS which can change frequently as web sites evolve. This necessitates a way to instruct browsers to fetch new copies of these particular files despite the expiry time not yet being reached. A common method of doing this is by appending a query string to the file URLs that changes when the file does, thus giving the appearance of a different file.

An example of this would be something like:

<link rel="stylesheet" href="/css/main.css?v2.0" type="text/css" />

This has the desired effect but requires an extra manual step of incrementing the version number each time the file changes, which is easy to forget to do.

A better approach is to have something appended automatically when a file changes. A great way of doing this is to code your site to automatically check the last-modified date of your static files and append a Unix timestamp in the query string:

<link rel="stylesheet" href="/css/main.css?1242089980" type="text/css" />

This value is guaranteed to increment when the file changes but will remain the same otherwise. Best of all, once you set it up you never have to touch it again.

But how do I do that?

Of course this doesn’t happen by itself; it requires some initial setup. If you’re working with Rails, this is done for you when you use certain asset helper methods, such as stylesheet_link_tag or image_tag. But what about PHP projects? CakePHP will do this as well but sometimes you don’t have the luxury of a framework like this.

Asset Helper

Asset Helper is a Wordpress plugin that gives you exactly this. Just drop it in, activate it via the Wordpress plugins panel, and start using your new helper functions for your CSS, JavaScript, and images. Alternately, add it to your theme directory and load it via include() and you won’t even have to worry about activating it.

Once you have Asset Helper loaded, adding timestamped files is as easy as doing:

<?php stylesheet_tag('style.css'); ?>

Which will give you something like this:

<link rel='stylesheet' href='/wp-content/themes/theme-name/style.css?1242089980' type='text/css' />

Actually, it’s even smarter than that example shows. If you just want to include the standard style.css for your current theme, just call the function without an argument — the plugin will figure it out. You can include files from anywhere by using filenames, relative paths, or paths from the site root.

Of course you can also do this with your JavaScript and images by using the javascript_tag() and image_tag() functions, which operate in a similar way.

Asset Helper is also aware of static asset hosts — those secondary hostnames you can use for your static files to allow for more concurrent downloads. Just define the ASSET_HOST constant in wp-config.php and the generated tags will automatically point to your asset host instead of the primary site’s hostname.

How to use Asset Helper

Complete documentation and lots of examples are available on the Asset Helper documentation page. Asset Helper is released under the terms of the GNU General Public License (GPL) version 2. If you find this plugin helpful, a link back to my site would be cool, but it’s not required.

Update

Asset Helper now works as a stand-alone PHP library as well as a Wordpress plugin. See the documentation page for details (usage for WP sites hasn’t changed).

Download Asset Helper from the Wordpress plugin directory

I’ve been using the NTP pool on servers and workstations for years and have recently decided to give something back to the project that’s been so helpful to me. So as of yesterday, one of my servers is part of the pool. You can see my server’s statistics on the NTP pool web site.

How to use the NTP pool

Using the pool is easy: Just set your system’s timeserver to pool.ntp.org. Or, for better results, use one of the geographic zones such as us.pool.ntp.org (for the US), de.pool.ntp.org (for Germany), etc. In addition to the top-level global zone, there are zones for each continent, and many country-level zones to choose from. My server is in the global, North America, and US zones.

The system works by using round-robin DNS to return a random IP address each time you resolve a *.pool.ntp.org hostname, which spreads the load over the entire network of time servers (additional scoring is done based on a number of other factors, but that’s the high-level overview).

More about using the NTP pool.

How to join the NTP pool

To participate in the pool, you’ll need to configure your NTP daemon to sync with a few stratum 2 time servers, and then respond to outside requests. I won’t go into the details here but it’s a fairly simple process and is outlined well on the NTP pool web site.

More information on joining the pool.

If you’ve got a server with some cycles and bandwidth to spare, consider joining the pool. The resource usage is minimal so it shouldn’t have much, if any impact on the real work your server is doing. Servers are especially needed in Africa and South America, but North America has fallen pretty far behind Europe as well so no matter where you are, you can help.

But that’s often overkill. In many cases you just want to display headlines or a single latest post and don’t need all this other stuff. Additionally, this method only allows you to display content from a single WP site. If you want headlines from more than one site, you’re out of luck.

RSS to the rescue

It’s called Really Simple Syndication for a reason. If you just want content and don’t need all the other Wordpress functions, RSS is the way to go. You can show headlines and/or content from as many other sites as you want without incurring the overhead of loading the entire Wordpress framework, and you can cache the results so that pages loads are nice and quick.

Introducing SimplePie

Admittedly, this is a late introduction. SimplePie has been around for a few years now but it’s not as widely used as it maybe should be. It’s a great way to display external RSS or Atom feeds with a minimum of hassle. At it’s most basic, you can do this with just half a dozen lines of code. Let’s see how.

First, you need to download the SimplePie library. Unzip the file and copy simplepie.inc somewhere accessible to your web site. For this example, we’ll put it in a directory called /inc just inside your site’s DocumentRoot. I rename mine to simplepie.php for consistency with other libraries I use, but that’s not necessary. Here we’ll stick with the default .inc
extension.

In this article, I will show how to do four things commonly done with RSS feeds on the web.

1. Show the five latest headlines
2. Displaying the full content of the single latest post
3. How to display two feeds on a single page
4. Combining headlines from two feeds into a single list

A note about caching

SimplePie provides a great caching mechanism so that feeds don’t have to be retrieved on every page load. This requires a writable directory on the server where the feeds can be stored. By default this location is ./cache, meaning a directory called “cache” in the same directory as the file calling simplepie.inc. Be sure your web server can write to this directory, either by changing the permissions, ownership, or some other means, as appropriate for your setup.

The default cache time is one hour. Both this and the cache location are customizable but we’ll be sticking with the defaults here. See the SimplePie API reference for details when you’re ready to dig into this.

Getting started

So here we go. First, load SimplePie by adding this line to the top of the PHP page you’ll be using it on:

<?php 
include_once $_SERVER['DOCUMENT_ROOT'] . '/inc/simplepie.inc'; 
?>

Once it’s loaded, we’ll add a second line to create our SimplePie object and give it the location of the RSS or Atom feed we’d like to display:

<?php 
include_once $_SERVER['DOCUMENT_ROOT'] . '/inc/simplepie.inc'; 
$feed = new SimplePie('http://feeds.corvidworks.com/CorvidWorks');
?>

That’s all the prep work we need. Unless otherwise noted, you’ll use this code for all the examples below.

We now have the feed loaded and we can start playing with the contents.

Example One – Display five latest headlines

For this first example we’re simply going to display five recent headlines. A typical use case for this might be a someone who wants to automatically link to their latest blog content on another site or on a non-Wordpress page on the same site.

Once the above code is in place, we can start printing out the contents of the feed. First, we’ll probably want to display the title of the feed itself. For a Wordpress-based site, this is the same as the blog name.

<h1><?php print $feed->get_title(); ?></h1>

Now let’s get the contents. To do this, we’ll retrieve an array of posts from the SimplePie object and iterate through them.

<h1><?php print $feed->get_title(); ?></h1>
<ul>
<?php foreach ($feed->get_items(0, 5) as $item): ?>
    <li>
        <a href="<?php print $item->get_permalink(); ?>">
        <?php print $item->get_title(); ?></a>
    </li>
<?php endforeach; ?>
</ul>

(I broke the list item up into multiple lines so it’s easier to read.)

In the above code, you can see our call to SimplePie’s get_items() method. Call this method without the optional arguments will retrieve the entire feed, or pass arguments to get exactly what you want. The first argument specifies the element to start with. Remember, arrays begin with zero so use 0 here to start with the latest post. The second argument is the number of items you want — we’re using 5 for this example; use 10 if you want a longer list, 1 if you want a single item, or whatever is appropriate for your needs.

That’s it! You’ve now got a list of headlines, linked to the articles on the original site.

Example Two – Display the latest post content

Displaying the latest full post is pretty similar to the above but we’ll be introducing a couple new methods to retrieve a single post and display the post body (“description”, in RSS terminology).

<h1>Latest post from <?php print $feed->get_title(); ?></h1>
<?php $item = $feed->get_item() ?>
<h2><?php print $item->get_title(); ?></h2>
<?php print $item->get_description(); ?>

The interesting thing here is that we’re calling get_item() rather than get_items() (singular instead of plural). By default, this method will return the first item in the feed, which is your most recent post. Add an optional argument of a single integer to specify a different post.

The remaining code is basically the same. We’re using the same method to display the title but have added a call to get_description() for the post body.

Example Three – Show headlines from two feeds

A common use case for SimplePie is to display headlines from a number of sources. Say you’ve got a person web site that you want to show headlines from the various blogs you write for. Building on what we’ve done so far, this is no problem at all. Let’s see how.

Back up near the beginning of this article, I showed how to include the SimplePie object and instantiate an object for the feed you wish to display. We’re going to make a small change to that code here and also create a second SimplePie object for the new feed we’ll be adding.

<?php 
include_once $_SERVER['DOCUMENT_ROOT'] . '/inc/simplepie.inc'; 
$feed1 = new SimplePie('http://feeds.corvidworks.com/CorvidWorks');
$feed2 = new SimplePie('http://feeds.corvidworks.com/Cocktailia');
?>

So now we’ve got $feed1 and $feed2, two SimplePie objects for our two feeds. From here you just follow the five latest headlines instructions above, but using that block twice on your page, using the two different feed variables we’ve created here.

<!-- First feed - note use of "feed1" -->
<h1><?php print $feed1->get_title(); ?></h1>
<ul>
<?php foreach ($feed1->get_items(0, 5) as $item): ?>
    <li>
        <a href="<?php print $item->get_permalink(); ?>">
        <?php print $item->get_title(); ?></a>
    </li>
<?php endforeach; ?>
</ul>
 
<!-- Second feed - note use of "feed2" -->
<h1><?php print $feed2->get_title(); ?></h1>
<ul>
<?php foreach ($feed2->get_items(0, 5) as $item): ?>
    <li>
        <a href="<?php print $item->get_permalink(); ?>">
        <?php print $item->get_title(); ?></a>
    </li>
<?php endforeach; ?>
</ul>

Example Four – Combine headlines from multiple feeds

For our final example, we’re going to combine headlines from two feeds into a single list. You might do this if you’ve got multiple feeds on a similar topic (entirely unlike the feeds I’m using in this example). Once again, we’ll be changing how we instantiate our SimplePie object, this time passing an array of URLs instead of a single one.

<?php 
include_once $_SERVER['DOCUMENT_ROOT'] . '/inc/simplepie.inc'; 
$feeds = new SimplePie(array(
    'http://feeds.corvidworks.com/CorvidWorks',
    'http://feeds.corvidworks.com/Cocktailia'
));
?>

This results in a single object containing data from two feeds, instead of one object for each individual feed. Now we can display them as usual.

<ul>
<?php foreach ($feeds->get_items(0, 10) as $item): ?>
    <li>
        <a href="<?php print $item->get_permalink(); ?>">
        <?php print $item->get_title(); ?></a>
    </li>
<?php endforeach; ?>
</ul>

You won’t use get_title() here, as there is no one single title for multiple feeds. You also may want to increase the number of headlines you’re showing so you get a good sample from each feed. Note that these are displayed in date order so you may have an uneven number of posts from each (real world usage of this example gives me three headlines from this site and seven from Cocktailia).

Further reading

These examples are intentionally basic but they should cover the most common use cases for SimplePie. Once you’ve tried these things and familiarized yourself with how it works, your next stop should be the SimplePie web site itself, where they’ve got some very good documentation, a complete API reference, and lots of examples. Have fun!

This week the first of these was announced: Mosso Cloud Servers.

About Mosso Cloud Servers

Mosso is a Rackspace-owned company who specializes in “cloud” hosting services. Cloud Files is a static file Content Delivery Network (CDN), similar to Amazon’s S3 service, and Cloud Sites is an interesting take on managed hosting. Cloud Servers is the latest addition to the family.

At first glance, Cloud Servers looks like pretty much just another VPS service. But the interesting thing is that they’re priced on a utility model, starting at $0.015/hour with bandwidth added on at $0.08/GB incoming and $0.22/GB outgoing, all billed at the end of the month. So you pay as you go, and only pay for what you use.

Running the numbers gives us a base rate of $10.95/month for the server plus bandwidth. A low-traffic server using, say, 10 GB outgoing bandwidth per month, will cost a little over $13/month. Not a bad deal. You’ll have to use around 40 GB per month before you approach the $20/month range which is the standard price for a low-end VPS.

Built on Slicehost

Upon closer inspection, it becomes apparent that this service is built entirely on the Slicehost platform. The service levels are the same, the Linux distributions offered are the same, the web-based control panel looks very similar (except that it appears to have been rewritten in Java for the Mosso services), and most tellingly, the IP address I was assigned when I ordered one resolved back to the .slicehost.net domain. I even found the word “slice” in one or two places around the control panel.

What does this mean for Slicehost?

Probably not much, really. Slicehost and Mosso are sister companies in the Rackspace family, and you’re ultimately doing business with Rackspace no matter which one you choose. While it’s possible that a decreased interest in Slicehost’s offerings may not bode well for the future of the company, that’s something that’s quite a ways down the road. I think the target markets for these two competing services are different enough that it won’t be a problem.

Which one do I choose?

As an end-user wanting to use Slicehost’s service, you now have more choice. You’re getting the same thing either way, so the two remaining questions are a) whether you’d like to use other Mosso Cloud services such as the CDN, and b) how much traffic your server will get.

The new Mosso control panel controls all the Cloud family offerings, so this might be a good way to go if you expect to use Cloud Files as well. On the other hand, if you expect to run a high-traffic server you just might want to stick with Slicehost for the higher bundled bandwidth.

Whichever you choose, you’ll be getting the same great service you’ve come to expect from both Slicehost and Rackspace, so you really can’t lose.

Update (July 8, 2009): The Mosso family of services has now been rebranded as The Rackspace Cloud.

Due to the largely remote nature of my work, this probably doesn’t mean much to current clients, except that I now have a new telephone number and mailing address. I will still be traveling for in-person meetings for projects that require it.

I’ve updated my vCard, and it’s ready to be imported into the address book of your choice. My new mailing address will also appear on all future invoices.

Nothing else is changing, I’ll still be available to help you out with whatever your project needs.

As always, you can keep on top of what I’m doing by subscribing to my RSS feed.

Note: If you’re here looking for spamming tips, keep moving.

With that out of the way, one of the simplest ways to improve the ability of your VPS to deliver mail to others is to make sure your hostnames are in order. This is one of the most often overlooked steps, yet it can be fixed in under two minutes. Executive summary: your MTA should identify itself with a fully-qualified hostname, this name should resolve to your server’s IP address, and your IP address should reverse-resolve back to this name.

Here’s how to check if you need this, and how to fix it if you do. All the following commands are run after connecting to your server via SSH. Commands that require elevated privileges are prefixed with “sudo”. These examples use Ubuntu Linux with Postfix, but this advice applies to any internet server that needs to deliver mail, even Windows (but Windows admins will have to figure out how to do it on their own).

First, let’s see what your server’s hostname actually is.

$ hostname
milan.corvidworks.net

The value of hostname should be a fully-qualified domain name (FQDN), meaning one containing both host and domain parts. In this real-life example, this server’s hostname is milan and the domain is corvidworks.net.

If your server returns a single name (“foo”) or just a second-level domain name (“example.com”), the first thing you need to do is change it, substituting your desired name. Feel free to be creative here — too many people name their servers “server1″ or similar. I name all my machines after cities, for example. Best practice is to use a name that is not related to any services you’re running, so don’t name it “www.example.com” either. This name does not need to relate to the From: address your mail is using, or to any web site you’re hosting.

$ sudo hostname foo.example.com

Depending on your OS/distro, you may now need to edit a couple files as well. Your /etc/hostname file should read:

foo.example.com

and your /etc/hosts should include the line:

127.0.0.1    foo    foo.example.com

Once that’s done, you should see results similar to the following, again with your own hostname instead of mine:

$ hostname
milan.corvidworks.net
$ hostname -s
milan

Now that the system knows its own name, let’s move on to your MTA. I’m using Postfix but the principles applies to any MTA, although the instructions will differ. In /etc/postfix/main.cf find the $myhostname line and change it to match the FQDN you set for the server, and set $myorigin to match.

myhostname = milan.corvidworks.net 
myorigin   = $myhostname

Debian and Debian-based systems, such as Ubuntu, get $myorigin from /etc/mailname by default. Feel free to update or create that file or just change the value as shown here.

If this server is not handling mail for your domain, make sure $mydestination is correct. Unless you want mail to your own domain delivered locally, your domain name alone should not appear in this line.

mydestination = $myhostname, localhost.$mydomain, localhost

Restart Posfix and make sure it’s identifying itself correctly by connecting to port 25. You should see the fully-qualified name you entered above in the SMTP banner:

$ sudo postfix reload
postfix/postfix-script: refreshing the Postfix mail system
 
$ telnet localhost 25
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 milan.corvidworks.net ESMTP Postfix

(type “quit” to end the SMTP session)

Still with me? Great. The work on your server is done and all that’s left is DNS. This step is going to vary greatly depending on your specific setup, so I can’t give any real instructions here other than tell you what you need. There are two records that need to be set:

• An A record pointing your fully-qualified hostname to your server’s IP address
• A PTR record (“reverse DNS“) pointing your server’s IP address back to that same FQDN

The A record will be set up where ever your DNS is managed. This may be at your VPS provider, your domain registrar, or a third-party DNS hosting company such as DNS Made Easy. The PTR record will be set up by your VPS host. They may offer a way to do this via some sort of control panel, but failing that a support ticket should take care of it. If they don’t offer this service, find a new hosting company.

And that’s it. Give the new DNS records a chance to propagate and you’ll be able to verify them using host. New records should be visible almost immediately, while changes may take up to 24 – 48 hours.

$ host milan.corvidworks.net
milan.corvidworks.net has address 65.49.60.34
 
$ host 65.49.60.34
34.60.49.65.in-addr.arpa domain name pointer milan.corvidworks.net.

And that’s it! Doing this won’t magically guarantee that your mail will be delivered but it will definitely increase your chances.

This procedure is well documented on the Wordpress Codex but I’m writing it up here as well, as it’s a prerequisite to some other Wordpress techniques I’ll be discussing and would like to keep the instruction all in one place.

Portable Wordpress configuration file

This article also strongly recommends using the WP_SITEURL and WP_HOME constants in order to make your Wordpress configuration file more portable, which has the added benefit of making this sort of setup even easier, particularly for those modifying an existing Wordpress site. For background, read my portable Wordpress configuration article but if you’d rather just get to it, add the following two lines to your wp-config.php file, replacing “wordpress” in the first line to whatever directory you want to keep your Wordpress files in.

// ** Hostname settings ** //
define('WP_SITEURL', "http://${_SERVER['HTTP_HOST']}/wordpress");
define('WP_HOME',    "http://${_SERVER['HTTP_HOST']}");

New Wordpress installations

It’s easy. First, simply unpack Wordpress into a subdirectory of your site. Then all you have to do is copy the index.php file from the WP directory into the root directory of your site, and make a single change. Look for this line:

/** Loads the WordPress Environment and Template */
require('./wp-blog-header.php');

And change it to this, replacing “wordpress” in the path to whatever directory you installed WP into.

/** Loads the WordPress Environment and Template */
require('./wordpress/wp-blog-header.php');

And that’s it! Your blog content will now appear at the root of your site, and your admin area is now at http://www.example.org/wordpress/wp-admin/.

Moving your existing Wordpress installation

Rearranging an existing Wordpress site is a bit trickier than doing this with a clean installation, but don’t let this deter you. It’s still pretty straight-forward. As above, the first thing you should do is modify your wp-config.php file with the code shown above. This will save you the step of changing the URL settings in the WP administration section.

Once you’ve done this, create the folder you would like to store Wordpress in, making sure the name you choose is the same one you specified in the WP_SITEURL line in your config file. Then move (not copy) all your Wordpress files into this new folder. On a typical Wordpress 2.6 installation, these files include:

• Three folders: wp-admin, wp-content, and wp-includes
• Any files beginning with “wp-” and ending with “.php” (eg, wp-app.php, wp-atom.php, etc)
• index.php
• xmlrpc.php

The license.txt and readme.html files can be moved, deleted, or ignored, as you wish.

Once these files have been moved, copy (not move) that index.php back into the root directory and open it up in a text editor. Look for this line:

/** Loads the WordPress Environment and Template */
require('./wp-blog-header.php');

And change it to this, replacing “wordpress” in the path to whatever folder you just moved your Wordpress files into.

/** Loads the WordPress Environment and Template */
require('./wordpress/wp-blog-header.php');

No changes to your .htaccess file are necessary. Your admin area is now at http://www.example.org/wordpress/wp-admin/ but you should now see your blog appearing at the root of your site, just the way it always has.

Now that Wordpress is cleanly tucked away into it’s own folder, your web site directory is cleaner and more organized, you will now have an easier time updating Wordpress, and the way is paved for doing easier maintenance using some new features of WP 2.6.