Stay Organized

Using categories to divide your photographs by type is a great way to make it easier for visitors to navigate your site, especially as your portfolio of images continues to grow. For example, as you categorize photos as “Travel” or “Black and White,” you can then add those category pages to your site’s navigation bar. If you’re using your photo blog to generate business as a photographer, this means that someone who’s looking for some black and white images can easily take a look at your gallery of black and white photos. This guide explains how to add categories to your post, and you can follow these steps to add those category pages to your site’s menu.

When displaying a series of photos, you’ll see that there are a handful of options for inserting them into your post: slideshow, gallery, and individual images. If you’re adding a large amount of photos to a single post, you may want to consider using the gallery option. Too many photos on the front page can cause a slow load time for visitors. By loading your posts as thumbnails first, visitors get the full effect of the breadth and variety of your photographs at a single glance. If you’re looking for feedback, visitors can comment directly on your photo by clicking on the “Permalink” button in the gallery carousel.

When uploading multiple photos to your post, don’t forget to use our Drag and Drop uploader so that you can upload multiple files at the same time. This will even allow you to drag a group of photos from your computer directly into the upload area.

Become a Curator

When working on a series, curate your content so that you can focus on the quality of your photos, not quantity. This means hand selecting the best photos in your series, rather than posting all of them at once to get as much out there as possible. When choosing images to include in your photo gallery, consider the following:

An example of the Rule of Thirds (photo by Bryan Villarin).

• The rule of thirds: When cropping your photos, try using the “rule of thirds” for more visually interesting photos. The rule of thirds is a compositional guideline that proposes photographs should be able to be divided into nine equal parts by two horizontal and two vertical lines. The main elements of the picture should fall along or at the intersections of these lines. In the photo to the right, the primary focus of the picture—the two red chairs—are positioned at the lower-right intersection of the grid and the horizon falls along the top vertical line.
• Stay sharp: When choosing a photo to include in your post, you’ll want to prioritize images that are vibrant and clear. A photo that is blurry or faded isn’t as captivating as a sharp, bold image.
• Don’t be afraid to edit: Cropping your photos to maximize the focus or remove conflicting elements from the subject, playing with filters, and tweaking the colors (including white balance) on your photo can help to polish the edges on your favorite shot.
• Be aware of repetition: While you may have a ton of great photos in your series, do try to highlight images that are unique and distinct from each other. Four strong, individual photographs are more visually interesting than 10 slightly different stills.

Resources

There are a lot of great options out there for image editing tools. Since we’re big fans of all things open source at WordPress.com and Automattic, you may be interested in GIMP and Seashore, two open source image editing programs. Our very own Sara Rosso has a great tutorial on getting started with GIMP and Bryan Villarin has some excellent tips on creating better photos without expensive equipment.

Don’t forget to check out these other links for more information on photo blogging, licensing, and tools for your work:

• Creative Commons: Licensing information to protect your work.
• WordPress Mobile Apps: Phlog on the go with WordPress apps for your smart phone and tablet.
• WordPress.com Photography page: Find fellow photo bloggers via the WordPress.com Photography topic page.
• Daily Post Photo Challenge: Take the Friday Photo Challenge at The Daily Post.
• Flickr on WordPress.com: Learn how to integrate your Flickr photos into your WordPress.com site.

Now get to snapping!

Missed our previous posts? Take a gander at Part 1 and Part 2 here.

The Problem

In my adventures with WordPress I have come across some interesting needs. Recently I worked with a client that has seven authors that each write their own blog posts, with different categories depending on the audience. The problem they kept running into was that, when a user would view one blog entry, the next and previous links would switch authors. The client needed for the next_post_link and the previous_post_link to stay within the same category as well as the same author.

The WordPress functions for next_post_link and previous_post_link allow for keeping the links within the same category but not the same author. This is where manipulating the WordPress core files comes into play.

After reviewing filter hooks and action hooks, existing WordPress functionality isn’t going to get us there. So The next logical solution involves altering the link-template.php file.

The Solution

To limit post navigation to the same author and category, locate the link-template.php file in the /wp-includes/ folder, and edit using your favorite text editor (Notepad++ for me). In this file you will alter four functions. Locate the following lines in the link-template.php file:

function previous_post_link($format='« %link', $link='%title', $in_same_cat = false, $excluded_categories = '') {
	adjacent_post_link($format, $link, $in_same_cat, $excluded_categories, true);
}

Change that to the following:

function previous_post_link($format='« %link', $link='%title', $in_same_cat = false, $excluded_categories = '', $is_author = false) {
	adjacent_post_link($format, $link, $in_same_cat, $excluded_categories, true, $is_author);
}

Below the previous lines of code you should find this:

function next_post_link($format='%link »', $link='%title', $in_same_cat = false, $excluded_categories = '') {
	adjacent_post_link($format, $link, $in_same_cat, $excluded_categories, false);
}

Change that to the following:

function next_post_link($format='%link »', $link='%title', $in_same_cat = false, $excluded_categories = '',$is_author = false) {
	adjacent_post_link($format, $link, $in_same_cat, $excluded_categories, false, $is_author);
}

These changes are small. You should notice that the only changes made were adding $is_author = false to the function parameters and $is_author to the call to adjacent_post_link call.

On the next function you’ll be adding another parameter and adjust the SELECT query that is pulling in the next/previous post. Locate the following line that should look something like this:

function get_adjacent_post($in_same_cat = false, $excluded_categories = '', $previous = true) {
	...
	}

This block is fairly long so I’m only covering what’s being changed. On this line add the same parameter as before ($is_author = false):

function get_adjacent_post($in_same_cat = false, $excluded_categories = '', $previous = true, $is_author = false) {
	...
	}

Next, in this same function find the $where variable as shown below (roughly 50 lines into the function).

$where = apply_filters( "get_{$adjacent}_post_where", $wpdb->prepare("WHERE p.post_date $op %s AND p.post_type = %s AND p.post_status = 'publish' $posts_in_ex_cats_sql", $current_post_date, $post->post_type), $in_same_cat, $excluded_categories );

What we want to do next is alter this variable so it retains the author only when $is_author is true. To do this test the boolean value of $is_author and tack a little extra on the end of the $where variable.

$where = apply_filters( "get_{$adjacent}_post_where", $wpdb->prepare("WHERE p.post_date $op %s AND p.post_type = %s AND p.post_status = 'publish' $posts_in_ex_cats_sql", $current_post_date, $post->post_type), $in_same_cat, $excluded_categories );
	if($is_author)
		$where .= " AND p.post_author='".$post->post_author."'";

For the final change in the link-template.php file locate the following function:

function adjacent_post_link($format, $link, $in_same_cat = false, $excluded_categories = '', $previous = true) {
	if ( $previous && is_attachment() )
		$post = & get_post($GLOBALS['post']->post_parent);
	else
		$post = get_adjacent_post($in_same_cat, $excluded_categories, $previous);

Alter this function by the $is_author in the adjacent_post_link function and adding it to the get_adjacent_post call:

function adjacent_post_link($format, $link, $in_same_cat = false, $excluded_categories = '', $previous = true, $is_author = false) {
	if ( $previous && is_attachment() )
		$post = & get_post($GLOBALS['post']->post_parent);
	else
		$post = get_adjacent_post($in_same_cat, $excluded_categories, $previous, $is_author);

Now you’re ready to use this new option in the theme files. To “activate” the retain author function use something like this in your single.php:

<?php previous_post_link( '%link', '' . _x( '&larr;', 'Previous post link', 'twentyten' ) . ' %title','true','','true' ); ?>
<?php next_post_link( '%link', '%title ' . _x( '&rarr;', 'Next post link', 'twentyten' ) . '','true','','true' ); ?>

Setting the last value to “true” activates the retain author function for that link. This will ensure the link stays within the same author as well as the same date. Note, in the above example I have $excluded_categories since I also want to keep everything in the same category. For my client this was their “members-only” blogs.

Take Notice

It is important to note that if you update the root files of WordPress, such as updated from 3.3 to 3.4, it may over ride these changes and you’ll have to make the adjustments again.

Conclusion

This is a quick and simple solution to add more functionality to your WordPress sites when you have multiple authors and multiple categories. I would love to see WordPress implement this into their native install (nudge nudge). Doing research on getting this to work I found quite a few people who needed this functionality but couldn’t find a reliable way of getting it done. In most cases their solutions didn’t work or it required them to remove one function to get this working.

Of course, if anyone has a more elegant solution I welcome the input. I’m still looking into ways to get this same affect with hooks since updates to WordPress wouldn’t alter a theme’s functions file. I look forward to everyone’s feedback and hopefully this will solve a problem you’ve been having or guide you in the right direction.

About the Author

David Powell is a professional web master and freelance web designer and developer. When he doesn’t have his nose buried in a computer screen or design book he’s usually in the gym lifting heavy things or punching a bag. You can locate him at his website or on Google+.

mysqltuner is easy to install and use. You can download the Perl file or use an installer, such as yum (yum install mysqltuner) on Red Hat and CentOS.

Then, you can run perl mysqltuner.tpl or mysqltuner, follow the prompts for the database credentials, and wait for the results:

-------- Performance Metrics -------------------------------------------------
[--] Up for: 145d 4h 29m 13s (17M q [1.388 qps], 290K conn, TX: 100B, RX: 27B)
[--] Reads / Writes: 97% / 3%
[--] Total buffers: 168.0M global + 2.8M per thread (151 max threads)
[OK] Maximum possible memory usage: 583.2M (14% of installed RAM)
[OK] Slow queries: 0% (199/17M)
[OK] Highest usage of available connections: 8% (13/151)
[OK] Key buffer size / total MyISAM indexes: 8.0M/3.5M
[OK] Key buffer hit rate: 100.0% (120M cached / 13K reads)
[!!] Query cache is disabled
[OK] Sorts requiring temporary tables: 0% (751 temp sorts / 2M sorts)
[!!] Joins performed without indexes: 922026
[!!] Temporary tables created on disk: 35% (1M on disk / 4M total)
[!!] Thread cache is disabled
[!!] Table cache hit rate: 0% (400 open / 238K opened)
[OK] Open file limit used: 5% (58/1K)
[OK] Table locks acquired immediately: 99% (33M immediate / 33M locks)
[!!] InnoDB data size / buffer pool: 3.0G/128.0M

-------- Recommendations -----------------------------------------------------
General recommendations:
    Run OPTIMIZE TABLE to defragment tables for better performance
    Enable the slow query log to troubleshoot bad queries
    Adjust your join queries to always utilize indexes
    When making adjustments, make tmp_table_size/max_heap_table_size equal
    Reduce your SELECT DISTINCT queries without LIMIT clauses
    Set thread_cache_size to 4 as a starting value
    Increase table_cache gradually to avoid file descriptor limits
Variables to adjust:
    query_cache_size (>= 8M)
    join_buffer_size (> 128.0K, or always use indexes with joins)
    tmp_table_size (> 16M)
    max_heap_table_size (> 16M)
    thread_cache_size (start at 4)
    table_cache (> 400)
    innodb_buffer_pool_size (>= 3G)

Then, modify the settings you are comfortable with (typically in /etc/my.cnf or directly in the MySQL console to make temporary changes) and restart MySQL if necessary. You can then run mysqltuner at any time again in the future to get up-to-date recommendations.

What you get is a WordPress repo starter kit. WordPress is in a subdirectory (/wp/), content is in a custom directory (/content/), and uploads are mapped to /shared/content/uploads/, which is a Git-ignored location. Re-symlink as appropriate, or alter your deploy script to do the symlinking on the fly.

You get a nice clean wp-config.php with a few of my tips and tricks already implemented (like local-config.php support for local development). .htaccess is ready to go with WordPress rewrite rules for anyone running on Apache.

I don’t really expect people to use it exactly the way I have it set up (though feel free!). What’s more likely is that people will fork it, and then make it their own. For instance, you may want to add mu-plugins drop-ins that you frequently use. Have fun!

The original Notifications menu first appeared in the WordPress.com toolbar as a small orange button and a stream of activities related to your blogs and comments. It was a good start but we’ve had bigger plans all along. Today we deployed a new toolbar button and, more significantly, a new tab on the WordPress.com home page.

The New Button

The first thing you’ll notice is that there is no number. We axed it out of compassion. It all boils down to how people feel about inboxes. In giving you a notifications stream, the last thing we wanted to do was cause more stress! So we dropped the unread count and now the orange color simply means there are new notes since you last looked. An icon shows the type of your latest notification.  The icon now also refreshes while you’re on a page, no need to reload a page to see new notifications.

You might also notice that unread notes are still white until you open them, which turns them gray. We didn’t entirely remove the concept of read/unread; we just stopped counting them. Feel free to turn them all gray if that’s your thing, or let some notes stay unread. Either way, we won’t pester you with a number.

The New Panel

In case you like to browse back through older notifications, we built a page that lets you do that. Just go to the WordPress.com Notifications panel and scroll to your heart’s content. Are you proud of a certain achievement from last month? Relive old glories as often as you like.

Other than letting you scroll to older notes, the new panel isn’t much different than the one in the toolbar. That will change soon! We have a list of features to add, as well as new notifications to send, that will make the new panel one of your favorite places on WordPress.com.

Today we’re sending one thousand notes every minute (ten million per week) but we want to send more. We have lots of ideas for new notifications. What kind of things would you like to be notified about?

Small Print

These changes are not compatible with Internet Explorer versions earlier than 9. We will devote some time to maintaining backwards compatability as long as it doesn’t delay the development of new features for modern browsers, but we encourage you to upgrade. Meanwhile, the old version of the toolbar will be displayed for older IE browsers.

You’ll find endless inspiration by browsing through topics like recipe, grilling, and summer in the WordPress.com Reader, and discover tons of great ideas by exploring our collection of recommended food blogs.

Here are seven mouthwatering recipes from a handful of fantastic blogs that are sure to delight all summer long:

The Patterned Plate

Mango and Coconut Ice Cream

We Call Him Yes! Chef!

Grilled Skirt Steak and Artichokes

The Faux Martha

Strawberry Shortcake

In Pursuit of More

Kale Veggie Slaw with Sesame Miso Dressing

Just Homemade

Raspberry Meyer Lemonade

Love + Cupcakes

Mandarin Orange Creamsicles

The Craving Chronicles

Salty Sweet Strawberry Crisp with Lazy Basil Ice Cream

Do you have an all-time favorite summer recipe? What new recipes do you hope to try out this season?

Before I get into the guts of WordPress 3.4, I want to point you to a resource which highlights some of the thinking that is going into the development, now and in the future, of how WordPress is built. Andrew Nacin sent an email to the “hackers” mailing list discussing object-oriented development that informs the thinking of the core developers now that WordPress supports PHP 5.2 and true object-oriented programming.

While it may be over the head of non-developer types, the gist is that now that we (used loosely) can write code smarter, we’re working our way in that direction. Some of the code in WordPress has existed for “generations” of versions and is bulky and inefficient. With new tools at our fingertips, we can begin to approach the idea of refactoring some of this code in better ways. Backwards compatibility is always retained, however, in 99 out of 100 times. WE ARE NOT DRUPAL!

Without further adieu, however, let’s get into what you can expect in the new version of WordPress.

Embed Tweets with oEmbed

Since version 2.9, WordPress has supported a technology called oEmbed that, simply put, has allowed the inclusion of rich media in content in a very simple way. Simply paste a YouTube link on a new line, and WordPress turns it into a properly sized video. No embed code needed. Same for Vimeo, Flickr, Scribd and more. The entire list can be found on the Codex. Now, however, Twitter is supported. Simply place the URL of a tweet on it’s own line and… bam, you have this:

Twitter is an oEmbed provider that is supported out of the box in WordPress 3.4

— Aaron Brazell (@technosailor) May 23, 2012

Query Efficiency Improvements

The common bottleneck for all WordPress users are database queries and data “munging”… that is, what WordPress does with data when it’s returned from the database. The query that brings in all the necessary content necessary to render a page used to look like this:

This has been how the query has worked for years. Really since the beginning of WordPress. And while, in theory that works (and it does, again it has for years), the core reality of this approach is that all the data in the posts table matching the criteria in the WHERE clause is more data than is needed, thus causing potential performance problems.

The new approach is simple and elegant. The first database query simply fetches a list of post IDs that fit the criteria provided in the WHERE clause.

This approach means the amount of data in memory and floating around WordPress is concise and compact. PHP doesn’t have to work harder to traverse arrays or objects… it is simply a smaller list of data.

But what about the other data? We need the other data! Yes, in fact we do. But since WordPress has an object cache, much of this data is in the object cache. We don’t need to retrieve it from the database.

The second step is to look to the object cache for posts with IDs matching any of the IDs in the first dataset. Anything we can’t find is followed with a second query to get all the information matching the non-matched IDs using MySQL’s IN() function:

By changing how SQL and object caching is used, WordPress 3.4 finds new efficiencies. In the original ticket, developers were observing 2-3x speed performance improvements. I’ll drink to that.

Theme Customizer

Non-technical WordPress users will love the new Theme Customizer. Otto has a great write-up on this new feature. His video is above. The key takeaway from this new feature is that is possible now to customize a great number of things in a theme  from right within WordPress. On the fly. with a live preview.

Change your title, tagline, background color, image and more with a click of a mouse. I can see this being used to create child themes in the future, but for now, it manages settings that are already in WordPress (and accessible in other areas of the WordPress Admin) on the fly. The best way to really appreciate this feature is via Otto’s video above. Related: The best way to leverage this as theme developers is outlined in great detail in his post…

Bundled ‘Touch’ Support

We live in a touchy-feeley world. And by that, I mean mobile. Specifically iOS and Android. In WordPress 3.3, we saw adaptive design come to portions of WordPress. Adaptive design, for the uninitiated, is a technology that elegantly resizes a website to adapt to the the screen it is rendered on. It is a way for developers to create a single experience that works on desktop/laptop browsers as well as mobile interfaces with arbitrary resolutions.

As mobile continues to lead the charge in today’s web, WordPress 3.4 has bundled the jQuery UI Touch Punch library that will give front-end developers more tools to work with in making a website mobile-friendly. Simply include the library via wp_enqueue_script() and now your element has the .draggable() method available. This method enables “drag and drop” support that was previously unavailable and the one major caveat is that it does not support Windows 7/7.5 phones due to limitations in the IE9 browser.

HTML in Captions

Photo by Kyle McCluer and used under Creative Commons. Some Rights Reserved.

I’m trying to rotate between developer tools and user tools in this article, so at this time, I’d like to point out a simple yet important frustration in previous versions of WordPress. When you upload an image and use the media uploader to then insert an image, you have the option of writing a caption. Sadly, it was impossible to include HTML in previous WordPress versions.

Often times, linking the source of a photo is welcome and, possibly depending on the usage restrictions on a photo, required. Before, the only way to do that was to set a link in the media uploader and then the photo would be linked. Now, in WordPress 3.4, you can include basic HTML in your captions as I have done above.

XML-RPC Improvements

XML-RPC. The thing that allows the WordPress apps for Android, BlackBerry and iOS to function. The thing that allows offline editors to function by remotely communicating with WordPress through a public-facing API.

XML-RPC is a venerable technology that is based mainly on the Metaweblog API invented a decade ago. WordPress has supported this iteration of XML-RPC as well as the Movable Type XML-RPC and Blogger XML-RPC APIs for a long, long time. However, WordPress has also extended the Metaweblog API and added it’s own methods along the way.

No more. Instead of band-aiding a solution on top of a limited set of methods intended for blogging only, WordPress 3.4 includes a brand new WordPress XML-RPC API designed to support all the rich features that have evolved since WordPress started focusing on CMS-style features. It incorporates all the methods introduced before as extensions to Metaweblog such as wp.getOptions, wp.getMediaItem, etc and introduces new ones such as wp.getPostTypes and wp.getTaxonomies to name just a few.

It’s important to note that only WordPress products are likely to ship with support for this new API at first, but old capabilities will still exist and function, as backwards compatibility is ensured. As API clients add support for WordPress’ new capabilities, we will see more common usage.

Internationalization (i18n) Improvements

For international WordPress users, WordPress 3.4 continues the tradition of enhancing your experience. As we in the community have stated many times, i18n is incredibly important to WordPress growth and development. In discussing this article with someone inside of the WordPress core community, I am told 2 out of every 3 WordPress users are non-American. Additionally, I am told that 40% of WordPress installations are non-english.

That’s Huge!

The running list of i18n chages in WordPress 3.4 is here. Some notable changes include:

• Comma translation. While most languages use a comma as a separater (or delimiter), some do not. This enhancement is useful for languages like Chinese and Arabic that don’t use a comma.
• Single-Double quote translation. It’s odd to think, but some languages like Hebrew, actually have distinct meanings for jots that are punctuation marks in an English world.
• Default Timezones. It’s possible now to override the timezone WordPress uses in a translation. This, as you can imagine, is important when a language is largely spoken in one region in a single timezone.

Page Template Handling

For theme developers looking to put more organization around their theme file structure, a new change has gone in that has both an obvious, front-facing benefit as well as a background benefit. Now, you can place any page template inside a subdirectory of a theme. So you can now have a /pages/ subdirectory and segregate all of your extraneous one-off or multi-use page templates to that folder (or any folder). WordPress will identify all page templates in the theme root or in a subdirectory of a theme root and make them available for pages to use.

The background benefit of this comes in a new WP_Theme API that is lighter weight, more efficient and handles all the work for you. It’s important to note that most developers will never need to use this API and it is largely considered an “internals” thing.

In relation to the i18n improvements discussed earlier, the headers in these page templates are also now translatable. Simply include a Text Domain: and Domain Path: header in your style.css where the textdomain is the defined textdomain for translations (i.e. twentyeleven) and the Domain Path is the path relative to the stylesheet directory (i.e. the proper place the theme is regardless of if it’s a parent theme or a child theme) where the POT file is (/langs). I don’t want to get too deep into this as Andrew Nacin, the architect of this feature, plans to put out a field guide going into detail. Stay tuned to that.

Custom Header API

For a few versions now, WordPress has supported two functions add_custom_header_image() and add_custom_background(). These two functions have added new menus for designating header and background images to the Appearances menu.

WordPress 3.4 introduces a new API for dealing with custom headers and backgrounds and introduces new flexibility in terms of image sizes, etc. The two functions above have been deprecated (which means they’ll work for awhile but will ultimately go away, so use the new techniques) and replaced with new theme support. If you recall from previous version, we use the add_theme_support() function to, well, add support for a feature in a theme. To integrate the new stuff, include these lines in your theme functions.php:

Both function calls can take a second argument which must be an array of presets, but it’s entirely optional. To omit the second argument renders behavior as we’ve known it for some time. To include it allows theme developers to designate designate parameters for both elements, that can then be customized by the end user.

For custom headers, you may include defaults along these lines (gregariously stolen from the Codex):

Likewise, for custom background defaults you might have this:

Bonus

Did you know?

• PHP end of file closing PHP tags are now removed. Those are these – ?> Why is this important? Including the closing tag means that if there is any white space at the end of a file, PHP is likely to break. Omission means that PHP assumes a close tag at the end of the file and whitespace can’t corrupt. Personally I’ve argued for this in the past. The main opponent must have been in a coma when this was slipped through by other core developers.
• Distraction Free Writing, first introduced in WordPress 3.2 is now supported by all custom post types.
• The theme installer now has infinite scroll which is just kind of pretty aesthetic thing. It also defaults to keyword searches when you’re browsing for a new theme on the WordPress Theme repository.
• Internal functions and classes now output “rtl”, “ie7″, “ie8″, etc as classes for browser targetting.

Not much has changed in the week or so since I asked for testers but in case you missed that post here are the changes since 1.0:

• Use $_SERVER[ 'SERVER_NAME' ] to create cache directories. No more non existant blogs appearing in your cache supercache and blogs folders.
• Only create blogs cached directories if valid requests and blogs exist.
• Only clear current blog’s cache files if navigation menu is modified
• Added clean_post_cache action to clear cache on post actions
• Removed garbage collection details on Contents tab
• Added wp_cache_check_mobile cacheaction filter to shortcircuit mobile device check.
• Don’t delete cache files for draft posts
• Added action on wp_trash_post to clear the cache when trashed posts are deleted
• Show a warning when 304 browser caching is disabled (because mod_rewrite caching is on)
• New check for safe mode if using less that PHP 5.3.0
• Added wp_supercache_remove_cookies filter to disable anonymous browsing mode.
• Fixed garbage collection schedule dropdown
• Fixed preload problem clearing site’s cache on “page on front” sites.
• Fix for PHP variable not defined warnings
• Fixed problem refreshing cache when comments made as siteurl() sometimes didn’t work
• Preloading of taxonomies is now optional
• Domain mapping fixes.
• Better support for https sites. Remove https:// to get cache paths.
• Added AddDefaultCharset .htaccess rule back in and added an option to remove it if required.
• Added multisite plugin that adds a “Cached” column to Network->Sites to disable caching on a per site basis.
• Added WPTouch plugin to modify browser and prefix list in mobile detection code. Added support for that plugin’s exclude list.
• Fixed cache tester
• Filter the tags that are used to detect end-of-page using the wp_cache_eof_tags filter.
• Removed debug level from logging as it wasn’t helpful.
• Removed mention of wp-minify.

As ever, the support forum is the best place to go for help as I monitor it all the time. Before you post there use Google to search for any error strings and use the debug system in the plugin as it will probably tell you what’s going on.

Related Posts

• WP Super Cache 0.8.4, the garbage collector
• WP Super Cache 0.8.7
• WP Super Cache 0.9.9

The Moscow WordPress Meetup Group is growing and we recently held our third meetup, which was quite a success! We had a total of 12 attendees (including a 5 year old kid) and 4 presentations, around 30 minutes each:

• What’s new in WordPress 3.4
• Building a Wiki with WordPress
• The GNU GPL Explained
• An Into to HyperDB

We met on a Saturday morning and the weather was perfect, everybody seemed to enjoy it, so let’s hope this thing keeps growing. Got a great deal of positive energy and inspiration, exactly the kind of stuff I need before my trip to Bulgaria :)

Tags, topics, and phloggers, oh my!

Tags work to connect your blog to the larger WordPress.com community, so you can see others who are writing, or photographing, the same subjects as you. By tagging your post as “Photography” or “Black and White,” your posts will be included in the respective Topic page so that other viewers can find your site. If you haven’t added tags to your posts before, you can learn how to do so here.

However, tags can be used for more than just bringing traffic to your site, but as a networking tool as well. As your photo blog grows, taking some time to look at other photo blogging sites can both help you to find inspiration, tips and tricks, and new ideas, as well as put you in contact with your fellow photo blogging compatriots.

You can start following new topics in your WordPress.com reader by going to the WordPress.com Reader and inserting “Photography” or any related tag into the “Add a Topic” text box.

The Photography topic page from the WordPress.com Reader

Building Connections

One of the best ways to boost readership and build a following is to do the same in return. This means that when you see a photo blogger that you like, comment on their post! Comments and pingbacks help to create connections between bloggers and their readers.

Blogging is about community and sharing, and this sets the tone. Just recently, I wrote a blog post inspired by a post on 1000AwesomeThings.com. I linked back, and hopefully turned a bunch of new readers onto the site. Because there was a decent amount of traffic sent to his blog, or maybe because he received a pingback, Neil Pasricha then came and commented on my blog! This is the author of two #1 International Bestselling books! I was so thrilled. I emailed Neil to thank him, and that began a back and forth, where I was able to ask him his blogging tips.

From Bestselling Author Shares 3 Tips for Building Your Blog Audience

In browsing other photo blogs, you may see that many photographers add information about their camera and set up to each post. Generally, photo bloggers will include the camera they used to shoot the image, the aperture and f-stop information, and the lens. This is a great way to explain both the tools you’re using as a photographer and another method of contributing to the photo blogging community by sharing your experiences.

The Duotone theme automatically pulls your digital photo information and displays it in the left sidebar.

Protecting Your Work

Through consistent posting, commenting on other blogs, and tagging your posts, you can continue to build your photo blogging readership. As you get your work out there, it’s also important to make sure that it’s protected. For photo bloggers on WordPress.com, we recommend that you watermark your photos. This means adding a copy right, such as “© Erica’s Photography,” directly to your image with a photo editing program. Watermarking your photos helps to prevent others from taking your images and pretending they’re their own.

If you’re interested in licensing your work as well, the Creative Commons license is an excellent way to both protect your work, while still contributing to the photographic community as a whole. Creative Commons licenses establish you as the owner of your product, but still allow for others to use your work. For example, among the various Creative Commons licenses, you can state that anyone is allowed to use your work as long as it’s attributed to you and they’re not using it for commercial purposes. Better yet, they can follow all of the above rules, and may also build on your work, similar to sampling when it comes to music beats.

Now that your photo blog is well on it’s way, don’t forget to stay tuned for more tips and tricks with our final post on Photo Blogging 101. (Missed the first post? You can check it out here.)

The customizer provides a live preview as you play with Appearance settings, and can be used to customize a live preview of a new theme before you activate it, or to make changes to your existing theme. It allows you to edit the site title and tagline, custom headers and backgrounds, navigation placement, front page selection, and other options that vary by theme. It works with both free themes and premium themes. Shall we take a test drive?

Imagine you want to change themes. As you are browsing on the Themes screen, notice the new “Live Preview” link and click it.

You’re taken to the customizer. As you make changes, the preview in the right-hand part of the screen updates live so you can get things just right.

When things look the way you want them, click the Save & Activate button in the lower left (or Save & Purchase if it is a premium theme) and boom, your new theme and custom settings are live!

You can also use the live preview feature to customize your existing theme. On the themes screen in your dashboard, you’ll now see a “Customize” button that launches the previewer.

And don’t worry, you still have access to the regular screens for adjusting these and other features. Just use the navigation for the Appearance section like you always have.

So, please try it out, and let us know what you think in the comments! I hope you like  it as much as we do. If you hit any snags, let us know in the forums so that we can help.

But wait, there’s more!

Yes, more! Here are a couple of smaller additions also aimed at making it easier to customize your site and make it look just the way you want it.

• When choosing a custom header image, you can now choose from your Media Library. I looove this, because I have uploaded the same header image at least a dozen times to re-use it when I changed themes.
• For themes that support it, custom headers now have a recommended size rather than a fixed required size, so you can be flexible with the height and width of your header images. I love this too, because sometimes I really like a theme but the header image I want to use is taller or shorter than the theme design allows. Now, the power is in your hands to decide! The goal is for as many themes as possible on WordPress.com to support this feature, but you can see if we’ve added it to yours yet by checking the list of supported themes.

And one last thing…
If you know HTML, you can now add links and a little bit of formatting to your image captions. This is great for people who want to link a photo credit to the photographer’s blog or to a Creative Commons license, or want to make some text bold or italicized. At some point in the future we may add a WYSIWYG option, but for now you’ll just need to learn some basic HTML tags if you want to use this one. Just type the HTML right into the caption field in the image uploader, and your links will appear like magic. So this:

becomes this:

You can adopt adorable kittens at your local Humane Society.
Make a new friend and save a life today!
Photo by Jane Wells, saver of kittens

I’ve been wanting this feature for four years now, so I’m really excited.

Have fun with these new features!

*Fun Fact: While this feature was in development, it was originally conceived as a wizard, or guided walkthrough. We codenamed it Gandalf.

This example should explain it.

// on admin area enqueue the scripts
add_action( 'admin_enqueue_scripts', 'fb_admin_enqueue_scripts' );
function fb_admin_enqueue_scripts( $where ) {
	// separation in dev and live
	$suffix = defined('SCRIPT_DEBUG') && SCRIPT_DEBUG ? '.dev' : '';

	// enqueue of script, identifikation on the string-ID
	wp_enqueue_script(
		'example_script_id',
		plugins_url( '/js/my-example-script' . $suffix. '.js', __FILE__ ),
		array( 'jquery' ),
		'',
		TRUE
	);

	// data via Array
	// array with data; also possible via get_option( 'my_option_string' )
	$data = array(
		'some_string' => __( 'Some string to translate' ),
		'a_value' => '10'
	);
	// localize the data, identifier via script-ID and create object for JS
	wp_localize_script( 'example_script_id', 'js_object_name', $data );
}

With this little example everything is done on the PHP-side; the content of the array are known now as object js_object_name and can be use via the name-string js_object_name in JS.

Now some hints, which should help, if it comes to problems or which link to solutions via JSON directly.
The function wp_localize_script() decodes HTML Entities, which is kind of important, but not always the perfect solution. The function uses json_encode(), which can let to problems in multi-dimensional arrays in connection with the decoding of entities. As soon as the array has more than one dimension, I recommend JSON without the WP Core solution via wp_localize_script().

With WordPress 3.4 it will get better and the function will be more useful - let's see. I currently use on multiple dimensions rather JSON directly. The solution from the core would be nice, I like the handling and it would be clearly and comprehensively utilizable.

Fear not, my fellow blogging friends. We’ve got you all covered today with a theme that will make you want to stop time and write about everything in your lives until you can’t write anymore.

A Simpler Time, designed by Denise Chandler, is a theme that’s beautiful, bold, and memorable—pretty much exactly like the types of stories you’ll be writing alongside it on your WordPress.com blog:

A Simpler Time: Single Post

It’s a traditional blog theme in the sense that it offers everything you’ve come to expect from a WordPress theme—widgets, custom menus, and custom headers, and more—and it also looks incredible. If you’d also like to mix it up with different colors and fonts, try the Custom Design upgrade. You can do all of that and more.

A Simpler Time is a premium upgrade for your blog; read more about its features on the Theme Showcase or dive right into previewing it on your blog from Appearance → Themes.

While performing a search for Conditional Statements, the first result was the one I was looking for. However, if you want the results to strictly be within the Codex, I came across this link shared by Otto on the Documentation mailing list. While giving this method of searching the Codex a try, I found it difficult to find the Conditional Statements page I was looking for that was easily displayed by the Google Custom Search box. Even by checking each box, I failed at finding the page using both Conditional Statements and Conditional as my search terms.

My advice, stick to using the Search box that exists on the Codex page.

No related posts.

Fatal error: Allowed memory size of 67108864 bytes exhausted (tried to allocate 1203208 bytes) in /home/*****/public_html/wp-admin/includes/class-pclzip.php on line 4215

This happens quite a bit but it’s not a bug in WordPress or your new plugin or theme, you simply need to let PHP use more memory on your server. Thankfully WordPress makes it easy to do this. You must define a constant, WP_MEMORY_LIMIT in your server’s wp-config.php like this:

define(‘WP_MEMORY_LIMIT’, ’128M’);

The error message will give you an idea of how much memory is required. The error message says it tried to allocate 1203208 bytes or just over 1MB of memory. The limit here is 67108864 bytes, or 65536KB which is 64MB so here I’d need a WP_MEMORY_LIMIT of more than 66M. The error message will go away once PHP has enough memory but be sure to test it.

If you allocate too much memory your server could start eating into disk swap space. Also be aware that each Apache child process is allowed to use that much memory so if you had ten processes it could use ten times the memory limit in a worst case scenario. If that happens you’ll need more RAM or you’ll have to figure out what’s using so much memory.

There’s also a WP_MAX_MEMORY_LIMIT constant. By default it’s 256M and it’s currently only used when uploading images.

On the off chance that you don’t have WordPress installed and you came here from a search engine, then you’ll want to use ini_set() somewhere early in the PHP process to increase the memory limit:

ini_set(‘memory_limit’, ’128M’);

Finally, I love that the wp-config.php codex page is the first result of a search for WP_MEMORY_LIMIT.

Related Posts

• Memory stick weirdness
• There is a memory leak in PHP. …
• Update on the status of php ac …

A similar problem arises when the source of the scripts is not just written in the footer area of WordPress, but outsourced to a file and via wp_enqueue_script() included. Only then WordPress can manage, compromises and optimizes these scripts for delivery. Therefore I would like to show two examples, how to pass data from PHP to JS.

The first snippet uses the pass of values ​​via JSON to get the values ​​from the database with the current resources in PHP and the script stores directly in the header of the page the values ​​as an object.

add_action( 'admin_enqueue_scripts', 'fb_print_scripts' );

function fb_print_scripts() {
	global $current_screen;

	if ( isset( $current_screen -> id ) && ! in_array( $current_screen -> id, array( 'post', 'page' ) ) )
		return;

	if ( is_plugin_active_for_network( plugin_basename( __FILE__ ) ) )
		$options = get_site_option( 'my_options_id' );
	else
		$options = get_option( 'my_options_id' );

	if ( ! $options )
		return;
	?>
	<script type="text/javascript">
		var my_json_object = <?php echo json_encode( $options ); ?>;
	</script>
	<?php
}

The above function gives the values ​​from the database as a JSON object in the head of the backend, as the page was requested in the first step of the function. Via $current_screen it will be checked so it will be only delivered if you are on one of the defined pages (post, page).

The next step is common practice and best solution to include scripts in WordPress. Thereby I will include the JS file, which then has accesses to the JSON object.

add_action( 'admin_enqueue_scripts', 'fb_admin_enqueue_scripts' );

function fb_admin_enqueue_scripts( $where ) {

	if ( ! in_array( $where, array( 'post.php', 'post-new.php', ) )
		return;

	$suffix = defined('SCRIPT_DEBUG') && SCRIPT_DEBUG ? '.dev' : '';

	wp_enqueue_script(
		self :: get_textdomain() . '_script',
		plugins_url( '/js/my_script' . $suffix. '.js', __FILE__ ),
		array( 'jquery', 'my_other_script' ),
		'',
		TRUE
	);

}

The script accesses directly the object that is processed.

jQuery( document ).ready( function( $ ) {

	if ( typeof my_json_object == 'undefined' )
		return;

// debug in console of Browser
console.dir( my_json_object ); 

});

Another solution will be presented in the following post at this series.

It’s now much easier for you and your commenters to keep track of the conversations you’re involved in across WordPress.com. Some recent tests have shown that by subscribing commenters to new comments by default, they are more likely to stay engaged and come back and comment more on your blog. With that knowledge, we’ve changed the default comment following behavior to help you get more conversations going on your blog.

We made the initial changes last week and after great feedback from you we just launched an update. Here’s how it works:

• By default, posting a comment will now subscribe you to receive follow-up comments via email for that specific post, keeping you updated on the conversation. This is indicated by the checked box in the comment form.
• If you have a WordPress.com account, you now have a global setting to change this so that by default you will not be subscribed. If you don’t have an account, then you can create one over here.
  
• If you don’t want email notifications for a thread, just uncheck the box when you post your comment. If you’ve disabled the feature, you can also subscribe to a specific thread by checking the box in the comment form.
  
• There is also a link at the bottom of every notification email that will allow you to change your subscription options.
  

If you’d like to find out all of the details about how this works, we’ve also updated our support documentation about following comments.

WordPress Core

WordPress is a Git submodule, with the content directory moved to the /content/ directory. This makes my Git repo smaller, as WordPress isn’t actually in it.

Underscores

For a theme base, I started with the Underscores starter theme by the theme team at Automattic. Underscores is not a theme itself… it’s a starting point for building your own theme.

Bootstrap

Next, I integrated Bootstrap, by Twitter, to handle the CSS base and the grid system. Bootstrap is a really powerful framework, and version 2.0 has great responsive design support, which allowed me to create a single design that scales up to big screens or down to tablet or phone screen sizes. Try resizing it in your browser to see the responsiveness in action!

The CSS for the site is authored using LESS, which plays well with Bootstrap. I’m compiling/minifying/concatenating the CSS and JS using CodeKit, an amazing Mac OS X app that makes development a breeze.

Typekit

For web fonts, it’s hard to beat Typekit.

Subtle Patterns

I needed some patterns to use on the site, but I was frustrated with the licensing terms on many pattern sites I was finding. And then I found Subtle Patterns. Gorgeous, subtle patterns, liberally licensed. And hey, their site is WordPress powered too!

Posts 2 Posts

The site has the concepts of Departments, Needs, and Products. Each Department has multiple Needs. Each Need has multiple Products. I used Scribu’s phenomenal Posts 2 Posts plugin to handle these relationships.

Here’s the basic Posts 2 Posts connection code:

<?php

function hbns_register_p2p_relationships() {
	if ( !function_exists( 'p2p_register_connection_type' ) )
		return;

	// Connect Departments to Needs
	p2p_register_connection_type( array(
		'name' => 'departments_to_needs',
		'from' => 'department',
		'to' => 'need',
		'sortable' => 'to',
		'admin_box' => 'to',
		'admin_column' => 'any',
		'cardinality' => 'one-to-many',
	) );

	// Connect Needs to Products
	p2p_register_connection_type( array(
		'name' => 'needs_to_products',
		'from' => 'need',
		'to' => 'product',
		'sortable' => 'from',
		'admin_column' => 'any',
		'admin_box' => array(
			'show' => 'any',
			'context' => 'advanced',
		),
		'cardinality' => 'many-to-many',
		'fields' => array(
			'description' => 'Description',
		),
	) );
}

add_action( 'wp_loaded', 'hbns_register_p2p_relationships' );

I created a Custom Post Type for each of Departments, Needs, and Products, and connected them all using Posts 2 Posts. The connection between a Need and a Product also contains description metadata, as seen here:

Since Posts 2 Posts was a required plugin for the site to function, I didn’t want there to be any possibility of accidental deactivation. So I wrote a quick mu-plugins drop-in to “lock” certain plugins on.

<?php
class HBNS_Always_Active_Plugins {
	static $instance;
	private $always_active_plugins;

	function __construct() {
		$this->always_active_plugins = array(
			'batcache/batcache.php',
			'posts-to-posts/posts-to-posts.php',
			'login-logo/login-logo.php',
			'manual-control/manual-control.php',
		);
		foreach ( $this->always_active_plugins as $p ) {
			add_filter( 'plugin_action_links_' . plugin_basename( $p ), array( $this, 'remove_deactivation_link' ) );
		}
		add_filter( 'option_active_plugins', array( $this, 'active_plugins' ) );
	}

	function remove_deactivation_link( $actions ) {
		unset( $actions['deactivate'] );
		return $actions;
	}

	function active_plugins( $plugins ) {
		foreach ( $this->always_active_plugins as $p ) {
			if ( !array_search( $p, $plugins ) )
				$plugins[] = $p;
		}
		return $plugins;
	}
}

new HBNS_Always_Active_Plugins;

Custom Post Types

I’m using the Products post type in a slightly odd way. You don’t ever go to a product URL. You instead go the URL for the Need that the Product fulfills, and that page lists all of the connected Products. As such, I wanted to make it so that URLs for products pointed to their Need, and I wanted to add an admin bar Edit link for the primary product on its Need page.

<?php
/*
Plugin Name: Post Links
Version: 0.1
Author: Mark Jaquith
Author URI: http://coveredwebservices.com/
*/

// Convenience methods
if(!class_exists('CWS_Plugin_v2')){class CWS_Plugin_v2{function hook($h){$p=10;$m=$this->sanitize_method($h);$b=func_get_args();unset($b[0]);foreach((array)$b as $a){if(is_int($a))$p=$a;else $m=$a;}return add_action($h,array($this,$m),$p,999);}private function sanitize_method($m){return str_replace(array('.','-'),array('_DOT_','_DASH_'),$m);}}}

// The plugin
class CWS_HBNS_Post_Links_Plugin extends CWS_Plugin_v2 {
	public static $instance;

	public function __construct() {
		self::$instance = $this;
		$this->hook( 'plugins_loaded' );
	}

	public function plugins_loaded() {
		$this->hook( 'post_type_link' );
		$this->hook( 'add_admin_bar_menus' );
	}

	public function add_admin_bar_menus() {
		$this->hook( 'admin_bar_menu', 81 );
	}

	public function admin_bar_menu( $bar ) {
		if ( is_single() && 'need' == get_queried_object()->post_type ) {
			$primary_product = new WP_Query( array(
				'connected_type' => 'needs_to_products',
				'connected_items' => get_queried_object(),
			) );
			if ( $primary_product->have_posts() ) {
				$bar->add_menu( array(
					'id' => 'edit-primary-product',
					'title' => 'Edit Primary Product',
					'href' => get_edit_post_link( $primary_product->posts[0] ),
				) );
			}
		}
	}

	public function post_type_link( $link, $post ) {
		switch ( $post->post_type ) {
			case 'product' :
				$need = new WP_Query( array(
					'connected_type' => 'needs_to_products',
					'connected_items' => $post,
				) );
				if ( $need->have_posts() )
					return get_permalink( $need->posts[0] );
				break;
		}
		return $link;
	}
}

new CWS_HBNS_Post_Links_Plugin;

For entering data about Products, I made a custom Meta Box that provided a simple interface for entering the Amazon.com link, the approximate price, and then a freeform textarea for key/value pairs and miscellaneous bullet points.

Misc

Because I’m using a Git-backed and Capistrano-deployed repo, I don’t want any local file editing. So I dropped this code in:

<?php

define( 'DISALLOW_FILE_EDIT', true );

function hbns_disable_plugin_deletion( $actions ) {
	unset( $actions['delete'] );
	return $actions;
}

add_action( 'plugin_action_links', 'hbns_disable_plugin_deletion' );

I was playing a lot with different Product thumbnail sizes, so Viper007Bond’s Regenerate Thumbnails plugin was invaluable, for going back and reprocessing the images I’d uploaded.

And of course, no WordPress developer should make a site without Debug Bar and Debug Bar Console.

Nginx and PHP-FPM

My server runs Nginx and PHP-FPM, in lieu of Apache and mod_php. My normal setup is to use Batcache with an APC backend to do HTML output caching, but I also have an Nginx “microcache” that caches anonymous page views for a short amount of time (5 seconds). But with this site, I wanted to cache more aggressively. Because there are no comments, the site’s content remains static unless we change it. So I cranked my microcache up to 10 minutes (I guess it’s not a microcache anymore!). But I wanted a way to purge the cache if a Product or Post was updated, without having to wait up to 10 minutes. So I modified the Nginx config to recognize a special header that would force a dynamic page load, effectively updating the cache.

Here’s the relevant part of the Nginx config:

	location ~ \.php$ {
		# Set some proxy cache stuff
		fastcgi_cache microcache_fpm;
		fastcgi_cache_key $scheme$host$request_method$request_uri;
		fastcgi_cache_valid 200 304 10m;
		fastcgi_cache_use_stale updating;
		fastcgi_max_temp_file_size 1M;

		set $no_cache_set  0;
		set $no_cache_get  0;

		if ( $http_cookie ~* "comment_author_|wordpress_(?!test_cookie)|wp-postpass_" ) {
			set $no_cache_set 1;
			set $no_cache_get 1;
		}

		# If a request comes in with a X-Nginx-Cache-Purge: 1 header, do not grab from cache
		# But note that we will still store to cache
		# We use this to proactively update items in the cache!
		if ( $http_x_nginx_cache_purge ) {
			set $no_cache_get 1;
		}

		# For cached requests, tell client to hang on to them for 5 minutes
		if ( $no_cache_set = 0 ) {
		        expires 5m;
		}

		# fastcgi_no_cache means "Do not store this proxy response in the cache"
		fastcgi_no_cache $no_cache_set;
		# fastcgi_cache_bypass means "Do not look in the cache for this request"
		fastcgi_cache_bypass $no_cache_get;

		include        /etc/nginx/fastcgi_params;
		fastcgi_index  index.php;
		try_files      $uri =404;

		fastcgi_pass phpfpm;
	}

Now I just needed to have WordPress ping those URLs with that header to refresh them when something changed. Here’s the “meat” of that code:

<?php
	public function transition_post_status( $new, $old, $post ) {
		if ( 'publish' !== $old && 'publish' !== $new )
			return;
		$post = get_post( $post );
		$url = get_permalink( $post );

		// Purge this URL
		$this->purge( $url );

		// Purge the front page
		$this->purge( home_url( '/' ) );

		// If a Product changes, flush its Need and that Need's Department
		if ( 'product' === $post->post_type ) {
			// Flush the connected need
			$need = new WP_Query( array(
				'connected_type' => 'needs_to_products',
				'connected_items' => $post,
			) );
			if ( $need->have_posts() ) {
				$this->purge( get_permalink( $need->posts[0] ) );
				// Now this need's connected Department
				$department = new WP_Query( array(
					'connected_type' => 'departments_to_needs',
					'connected_items' => $need->posts[0],
				) );
				if ( $department->have_posts() )
					$this->purge( get_permalink( $department->posts[0] ) );
			}
		// If a Post changes, flush the main Blog page
		} elseif ( 'post' === $post->post_type ) {
			$this->purge( home_url( '/blog/' ) );
		}
	}

	private function purge( $url ) {
		wp_remote_get( $url, array( 'timeout' => 0.01, 'blocking' => false, 'headers' => array( 'X-Nginx-Cache-Purge' => '1' ) ) );
	}

Boom. Now I get the benefit of long cache times, but with the ability to have updates go live quickly when I need to. The upshot here is that while I have Batcache installed, it’s not really going to get a lot of use, as the outer Nginx caching layer should handle everything. This doesn’t just mean that the site scales (Apache Bench has it handling many thousands of requests a second with ease), but that the site is really, really fast to browse. Your experience will vary according to network and geography, of course. But for me, I’m getting 34ms HTML delivery times for pages in the Nginx cache.

Questions?

So that’s how I did it. Let me know if you have any questions!

Discover details about what each showcase blog is doing with WordPress.com themes and customizations by clicking a thumbnail to see a colophon-style list of credits on the left.

We’ve also updated footer links so blog owners can show off the types of customizations they’ve made and visitors can learn more by clicking the “Customized” link in WordPress.com footers. A “Customized” link will appear next to the theme name for blogs that are using Custom Design tools like fonts or CSS.

Things we like to see when looking for showcase-worthy customizations are blogs with good traffic, beautiful design, well-written articles or stunning images, recent content updates, and involvement helping out in our CSS Customization forum.

Be inspired, customize your blog and make it that perfect place for your creations.

Getting started

Photo blogs, sometimes called phlogs, use pictures instead of words. While many photo bloggers choose a type of photo that they want to focus on, such as portraits, others use their photo blog to document their life’s events. Photo blogs come in a variety of styles, including those that focus on vacation photos or even snapshots of friends. With images, we can capture moments in our life in a way that sometimes words cannot.

When starting a photo blog, you’ll want to choose a theme with a wider content area to help to showcase your photos at full size. Similarly, choosing a theme that is minimalistic helps to reduce any noise that may detract from the focus on your photography. Popular photo blogging themes on WordPress.com include Nishita, Duotone, and Modularity Lite. Looking for some inspiration? Be sure to check out the photo blogs below or more of our recommended photo blogging sites for examples of photo-friendly layouts.

The Unknown Project, a WordPress.com photo blog using Anthem.

Tracey Capone Photography, a WordPress.com photo blog using Twenty Eleven.

Tomorrow Never Knows, a WordPress.com photo blog using Comet.

Want to add photo flair to your site without starting a whole new blog? Adding a photo blogging category to an existing blog is a great way to revamp your site. In fact, you may consider doing “Friday Phlogs” or a similar weekly special to help incorporate these tips consistently into your current site.

Tools of the Trade

What do you need to get started? Nothing but a camera and an internet connection. Photo blogging with a smart phone is growing increasingly simple, particularly with the Quick Photo button in the WordPress for iOS and Android apps where you can point, shoot, and publish. If you’re already a pro at the WordPress apps, you may be interested in taking a look at Camera+ and Flickr, which allow you to automatically share your photos to your WordPress.com blog.

On the left, QuickPhoto in WordPress for Android and on the right, QuickPhoto in WordPress for iOS.

If you choose to use a more traditional camera, there are few tips to keep in mind when uploading your photos to ensure they represent the full quality of your original picture.

• Don’t resize your photos after uploading them to WordPress.com. Instead, leave your images at full size so we can see your work in all of it’s glory. WordPress.com will automatically generate the appropriate dimensions for you.
• Make edits to your photos before uploading them.
• Save your photos as JPEGs. JPEGs are the best format for photos online. You can also use PNG if you’re looking to add a transparent image to your site.

Welcome to our series on photo blogging! Stay tuned for more tips and tricks over the next few weeks.