• site.org/blogname1
• site.org/departments/blogname2
• site.org/departments/blogname3
• site.org/services/blogname3

The association between blog IDs and sub-directory paths is determined in wpmu-settings.php, but the code there knows nothing about nested paths. So a person planning to use WordPress MU as a CMS must either flatten his/her information architecture, or do some hacking.

Challenge: hacking WordPress MU to support arbitrary directory paths for each blog

As with my multi-domain hack, the following assumes that you’re using the vhost=no setting, that you have access to and know how to manipulate your MySQL, that you have control over your DNS and know how to use it, and that you know how to configure Apache or similar. You’d also be smart to turn off any object caching you may have running, at least until we’re done doing direct database manipulation. The following also assumes that your wp-config.php sets the DOMAIN_CURRENT_SITE and PATH_CURRENT_SITE constants — if you’ve done a fresh install recently, it probably does, or you can check my domain mapping hack.

Hack The Path Mapping

Right at the top of wpmu-settings.php you can see how it strips all but the base of the URL path, but rather than mod that file, we can take advantage of an obscure MU hack: sunrise.php, which gets executed after some important WordPress components like the database class get loaded and before wpmu-settings.php.

To use sunrise.php, create a PHP file at /wp-content/sunrise.php and set define('SUNRISE', TRUE); in your wp-config.php.

Here’s the sunrise.php code I’m using:

if( defined( 'DOMAIN_CURRENT_SITE' ) && defined( 'PATH_CURRENT_SITE' ) ) {
	$current_site->id = (defined( 'SITE_ID_CURRENT_SITE' ) ? constant('SITE_ID_CURRENT_SITE') : 1);
	$current_site->domain = $domain = DOMAIN_CURRENT_SITE;
	$current_site->path  = $path = PATH_CURRENT_SITE;
	if( defined( 'BLOGID_CURRENT_SITE' ) )
		$current_site->blog_id = BLOGID_CURRENT_SITE;

	$url = parse_url( $_SERVER['REQUEST_URI'], PHP_URL_PATH );

	$patharray = (array) explode( '/', trim( $url, '/' ));
	$blogsearch = '';
	if( count( $patharray )){
		foreach( $patharray as $pathpart ){
			$pathsearch .= '/'. $pathpart;
			$blogsearch .= $wpdb->prepare(" OR (domain = %s AND path = %s) ", $domain, $pathsearch .'/' );
		}
	}

	$current_blog = $wpdb->get_row( $wpdb->prepare("SELECT *, LENGTH( path ) as pathlen FROM $wpdb->blogs WHERE domain = %s AND path = '/'", $domain, $path) . $blogsearch .'ORDER BY pathlen DESC LIMIT 1');

	$blog_id = $current_blog->blog_id;
	$public  = $current_blog->public;
	$site_id = $current_blog->site_id;
	$current_site = sl_get_current_site_name( $current_site );
}

function sl_get_current_site_name( $current_site ) {
	global $wpdb;
	$current_site->site_name = wp_cache_get( $current_site->id . ':current_site_name', "site-options" );
	if ( !$current_site->site_name ) {
		$current_site->site_name = $wpdb->get_var( $wpdb->prepare( "SELECT meta_value FROM $wpdb->sitemeta WHERE site_id = %d AND meta_key = 'site_name'", $current_site->id ) );
		if( $current_site->site_name == null )
			$current_site->site_name = ucfirst( $current_site->domain );
		wp_cache_set( $current_site->id . ':current_site_name', $current_site->site_name, 'site-options');
	}
	return $current_site;
}

The first few lines of the code do pretty much the same as the start of the wpmu_current_site() function in wpmu-settings.php, but starting with line 8 it takes a big departure.

That’s where it splits the requested URL path like /path/to/blog/and/stuff/ into pieces and constructs an SQL query against the wp_blogs table to identify the correct blog to serve the request. The following example shows how:

SELECT *, LENGTH( path ) as pathlen
	 FROM wp_blogs
	 WHERE domain = 'domain.org' AND path = '/'"
	  	 OR (domain = 'domain.org' AND path = '/path/')
	 	 OR (domain = 'domain.org' AND path = '/path/to/')
	 	 OR (domain = 'domain.org' AND path = '/path/to/blog/')
	 	 OR (domain = 'domain.org' AND path = '/path/to/blog/and/')
	 	 OR (domain = 'domain.org' AND path = '/path/to/blog/and/stuff/')
	 ORDER BY pathlen DESC
	 LIMIT 1

Optimization note

Setting a maximum depth (and array_slice( $patharray, 0, $maxdepth )) would allow the query to be cached up to that depth. Otherwise, the query must be executed for every page load. The $maxdepth could either be set arbitrarily, or could be determined automatically based on the maximum path length of registered blogs.

Setting Up New Blogs

Once you’ve hacked the path mapping (and tested that it didn’t break your current site), you can add a new blog at a nested path.

Create a new blog in the MU blog admin.

Unfortunately, MU strips the slashes from the URL path you just tried to set.

The new blog you just tried to create, but with a very different path.

Fortunately, you can set the path correctly in the MU blog editor, and it won’t break the path when you save there.

Set the blog path in the MU blog editor, MU won't break it when you save it this time.

Once you create the new blog, try to load it in your browser. You’ll quickly notice the stylesheet is missing, though the blog works and functions properly.

Hack The .htaccess

WPMU uses the following .htaccess rewrite rule to properly direct requests for files on the real filesystem:

RewriteRule  ^([_0-9a-zA-Z-]+/)?(wp-.*) $2 [L]

Obviously, that rule won’t work for deep paths, so I’ve replaced it with this rule:

RewriteRule  ^(.+)?/(wp-.*) /$2 [L]

And with that, you should be done.

WordPress MU is a solid CMS to support a large organization. Each individual blog has its own place in the organization’s URL scheme (www.site.org/blogname), and each blog can have its own administrators and other users. Groups of blogs in WPMU make up a “Site” and one or more Sites can be hosted with a single implementation. (I’m capitalizing Site for the same reason WordPress docs capitalize Page) Each Site has a defined set of administrators and options controlling various features. You might, for instance, lock down the plugins on your blogs.site.org, while keeping it open on your www.site.org. Or maybe you’d like to let your helpdesk staff create new blogs at blogs.site.org, but not at www.site.org. That’s what WPMU’s notion of Site can help you control.

Challenge: setting up service on multiple (sub-) domains

WordPress MU makes it easy to host both blogs.site.org and www.site.org within a single implementation, but there’s little documentation for how to do it.

Once you get WPMU up and running on one of your domains you can add another. The following assumes that you’re using the vhost=no setting (correct: I really mean vhost=no), that you have access to and know how to manipulate your MySQL, that you have control over your DNS and know how to use it, and that you know how to configure Apache or similar. You’d also be smart to turn off any object caching you may have running, at least until we’re done doing direct database manipulation.

Some might ask why I’m not simply using Donncha’s plugin, and the answer is simple: it only works for vhost=yes sites. For my own use, I find that sub-directories are easier for users to make sense of (go ahead, try to tell your mom to go to “myblog.sub.domain.org“).

Set up your web server

If you’re using Apache, you’ll either need to create an IP-based virtual host or manually configure your name-based virtual host for every (sub-)domain you plan to serve. Why: WordPress will handle the domain mapping for you, so it’s better to keep Apache out of the way and let WPMU own the entire IP.

Set up your DNS

Point each subdomain you plan to host in WordPress to your webserver. You can use a wildcard domain, but you don’t have to.

Create a new blog in WPMU

It doesn’t matter what you call it or what the path is, just create one. Now go edit it in the Site Admin:

Change the domain and path to match your new domain.

One quirk of WPMU is that it strips “www” from any domain name you enter (or is requested), so don’t bother trying to enter it (unless you’re willing to do some hacking to make it work). WPMU stores domain and path information in three locations: the wp_#_options table for the blog, the wp_blogs table, and the wp_sites table. When you edit a blog in the Site Admin, you’ll get a chance to edit the domain and path for both the wp_#_options and the wp_blogs tables. Clicking the helpful checkbox above will do most of that for you, but you’ll need to manually update the Upload Path.

Now make sure the new domain is shown in the blog's options as well.

You might be able to load the blog at the new URL as soon as you update those settings, but recent versions of WPMU set some constants in wp-config.php that can get in your way.

Reconfigure wp-config.php

Your wp-config.php might have something like this:

$base = '/';
define('DOMAIN_CURRENT_SITE', 'sub.site.org' );
define('PATH_CURRENT_SITE', '/' );
define('SITE_ID_CURRENT_SITE', 1);
define('BLOGID_CURRENT_SITE', '1' );

Those constants override the database checking that goes on in wpmu-settings.php to map the requested domain to a site. You have three choices: leave it as it is (and use only one “Site”), remove it and have WPMU do the mapping against the database, or expand the hard-coded mapping to include other sites.

I’ve used code like the following to do just that:

if( preg_match( '/(.+?\.)?([^\.]+?)\.site.org/i', 'www'. $_SERVER['SERVER_NAME'] , $matchedsubdomains ))
{
	switch( array_pop( $matchedsubdomains )){
		case 'connect':
			define('DOMAIN_CURRENT_SITE', 'blogs.site.org' );
			define('PATH_CURRENT_SITE', '/' );
			define('BLOGID_CURRENT_SITE', '1' );
			break;
		case 'www':
		default:
			define('DOMAIN_CURRENT_SITE', 'site.org' );
			define('PATH_CURRENT_SITE', '/' );
			define('BLOGID_CURRENT_SITE', '2' );
			break;
}
}
else
{
	define('DOMAIN_CURRENT_SITE', 'site.org' );
	define('PATH_CURRENT_SITE', '/' );
	define('BLOGID_CURRENT_SITE', '2' );
}

Set up your new Site

Once you have your new sub-domain working with one blog, you can create your new Site. Even if you don’t plan to create separate management policies for the different sites, it’s easier to create new blogs at each sub-domain if they each have their own Site.

Go in to your MySQL tool of choice and browse the wp_site table. There you’ll see just one row, but if you’ve made it this far you can also probably figure out how to create a new row representing the site at the new sub-domain. And once you do that, you can change the entry in the wp_blogs table to associate it with your new Site.

Set up the admins of the new site

Creating the new entry in wp_site doesn’t set the options for the new Site, and that means there are no Site administrators yet. Once again in your MySQL tool of choice, open up the wp_sitemeta table and look for an entry with meta_key = 'site_admins'. The meta_value for that entry is a serialized array containing WordPress usernames of the people who have site-wide administration privileges on the first Site. I’m assuming that if you have MySQL access you’re also a Site admin, so the easy thing to do is copy that row and change the site_id to match the auto-increment value from the new wp_site entry you made in the last step.

With the database manipulation done, you should now be able to go to the WP dashboard at your new Site, visit the WPMU admin options screen, and set the other options as necessary. You could decide to make one of your Sites open registration (remember, however, that users are shared across all Sites), while making other Sites more closed. And, obviously, you can delegate different Site admins for each Site.

Sub-domains or just different domains?

It’s worth noting that the instructions so far apply to both sub-domains and domains. You can use a single implementation of WPMU to manage content at both lolzors.org and tehsite.org. The detail about sub-domains really only applies to the next part. It’s also worth noting that you can support an arbitrary number of blogs, sites, and domains; I’m just using two sub-domains as an example.

Challenge: unified log in cookies

What’s the point of hosting multiple sub-domains with one WPMU implementation if you’ll need to log in separately at each one?

Set your cookie path

Setting a cookie path that that’s broad enough to cover the entire domain will solve this:

define('COOKIE_DOMAIN', 'site.org');
define('ADMIN_COOKIE_PATH', '/');
define('COOKIEPATH', '/');
define('SITECOOKIEPATH', '/');

Avoid conflicts with other WordPress installations at your domain

But having such a broad cookie domain can interfere with other WordPress implementations. You’ll have to solve that by setting a unique cookiehash:

define( 'COOKIEHASH', 'asdf_arbitrary_string' );

You’d do better to keep it shorter than that, though.

Challenge: unified log in location/URL

WordPress MU is happy to handle authentication requests wherever it hosts a blog, but some organizations prefer to funnel all authentication requests through a single location. The idea is to provide some protection against fishing (assuming users can ever be taught to look at URLs) and make it easer to integrate external applications.

Filter login_url and logout_url

Set the log in and log out path to whatever you want, just make sure the destination knows how to create (or destroy) the WordPress cookies.

$hack_base_domain = 'site.org';

function hack_login_url( $path ){
	global $hack_base_domain;

	return preg_replace( '/^.+?\/wp-login.php/' , 'https://login.'. $hack_base_domain .'/wp-login.php', $path );
}
add_filter( 'login_url' , 'hack_login_url' , 10 );
add_filter( 'logout_url' , 'hack_login_url' , 10 );

Filter allowed_redirect_hosts

WP will normally block redirects outside the web root of the active blog, so you’ll need to tell it about your other sub-domains.

function hack_allowed_redirect_hosts( $allowed_domains ){
	global $hack_base_domain;

	$allowed_domains[] = $hack_base_domain;
	$allowed_domains[] = 'www.'. $hack_base_domain;
	$allowed_domains[] = 'blogs.'. $hack_base_domain;

	return $allowed_domains;
}
add_filter( 'allowed_redirect_hosts' , 'hack_allowed_redirect_hosts' , 10 );

After writing the project page for wpSMS I didn’t have much more to say in a blog post announcing it. The cool thing about writing Pages in WordPress is that I can create a taxonomy like /projects/wpsms/ to place them in. The downside is that new pages never appear in the RSS feed.

So I need both the page and a blog post to announce it. I could have simply copied the content from the wpSMS page into a blog post, but that creates confusion and splits the audience between the two pages. Instead, I’m using two bSuite features: the [include] shortcode and the post redirection support.

1. Create the page.
2. Start a new post.
   1. In the post body put the include shortcode like this: [include post_id="123" field="post_content"].
   2. In the custom fields put an entry with the key: “redirect” and the full URL to to your page.
3. Relax, you’re done.

The include shortcode will copy all the content from the page (so you don’t have to manage it twice), and the redirect custom field will tell bSuite to redirect anybody trying to read that post to your page.

Write excerpts, tag, and categorize your pages

WordPress excerpts are an underused but powerful feature that allow you to explain to your readers why they should read the page you wrote. Tagging and categorization of pages help improve the findability of those pages, especially in search engines. Native WordPress doesn’t support excerpts, tags, or categories for pages, but bSuite does. Whenever you edit a page you’ll see the same tools that you do when writing posts.

Automatically insert anchors in your page

There’s nothing wrong with long pages, but you can make it easier for your readers to navigate them by if you break it up into sections. When you use the innerindex shortcode, bSuite will insert an automatically index of all the headings (the h1 through h6 tags) in your page. This also works in regular blog posts.

Automatically list sub-pages

You can easily organize pages into any structure that suits your content, but having to manually manage all the links into that hierarchy can be tiresome. The list_pages shortcode solves that in a jiffy. Options to the shortcode allow you to set how deep the list is and other features.

Automatically list sub-pages with excerpts

One especially useful feature of the list_pages shortcode is the ability to include the excerpt from each of the listed pages. You can even put the innerindex shortcode in the excerpt (see that at work here).

The question:

What’s a good user-friendly Macintosh web development program? A friend called. She’s thinking of buying Dreamweaver, but is afraid it will be overkill. She found Frontpage to be easy and needs something similar.

My answer:

If the intent is to design individual pages on an unknown number of sites, then I don’t have a recommendation.

If the intent is to build a site (or any number of sites), then I’d suggest looking at WordPress. It’s an open source CMS, and there’s a hosted version that makes it easy to try out at WordPress.com.

What I didn’t say, well, it was buried in my answer, was that I see a big difference between designing a page and building a site. The tools are very different.

wordpress, web design, site management, cms, content management, questions

New AJAX-happy CMS: MooFlex, more info at Ajaxian (and in their podcast).

cms, opensource cms, web application, mooflex, ajaxian, content management system

Zach got a call from the Serena Collage rep who rattled off this list of customers in New England:

• Boston College
• Northeastern
• Bristol Community College
• UMass Lowell

cms, content management, web content management, serena, collage, serena collage, content management system, vendor, commercial cms

We got the demo yesterday of Sungard/SCT’s Luminis Content Management Suite (sales video). I mentioned previously that the sales rep thinks Pima Community College and Edison College show it off well.

Here’s what we learned in the demo:

It started with the explanation that data is stored as XML, processed by JSP, and rendered to the browser as XHTML according to templates, layouts, and “web views.” It was later explained that the product was “web server agnostic” and could run under Apache, IIS, SunOne, or others. This works because the only relationship between the web server and LCMS is on the file system. LCMS works up the pages, then spits them out onto the filesystem to be picked up by the webserver. LCMS does not dynamically generate the pages, and it has no features to support dynamic content.

LCMS supports three modes for admins and content authors to view and edit content: in-context, “site studio,” and some other mode that wasn’t demonstrated. WYSIWYG editing was via the Real Objects editor. They were proud of the editor’s ability to accept content, including a table, pasted in from MS Word, but a look at the code revealed some of the same ugliness that we’ve seen from an export directly from Word.

The software is workflow heavy and our demonstrator had to “manually promote” content with every example. He assured us this would not be necessary under production circumstances, but the product had the appearance of having been designed to slow or prevent changes to web content rather than streamline the process.

From now on I’ll be asking the following question at all demos:

The library is hosting an exhibition next week. Please walk us through the process of creating a new page to describe and promote the event and then integrate that page in the library’s site taxonomy.

I mention this because the demo didn’t show us anything like that. We saw only the editing of pages and it looked frustratingly cumbersome, with one example requiring several return visits to the site studio to promote an edited page from in-progress to approved to live (three is the minimum number of steps, but we were told we can have 15 or 20 or more if we wanted). If the content author didn’t have promotion authority, then the process could require the involvement and coordination of two or more people. It’s easy to imagine days passing before page corrections went live and weeks passing before new content could be put online.

That said, the site admins have it a little easier (if only because one assumes they have supreme permissions for everything). The templating didn’t look bad, but because the product doesn’t generate any dynamic pages, it couldn’t take advantage of some automation opportunities (the demonstrator was excited to tell us the footer text — “copyright 2005” — could be globally changed by editing a singe file, but we were curious why the copyright date wasn’t dynamically generated).

Permissions can be assigned per object by user or group. These details are stored in the Luminis LDAP, but they’re not shared with or based on any group or permission we’re already managing. That is, we’ll have to pay attention to provisioning (and de-provisioning) specific to the CMS. It’s amusing that vendors claim LDAP integration but remain ignorant of identity management issues.

There are seven levels of permission for each user or group on each object:

• none
• browse
• read
• relate
• version
• write
• delete

And then there are these extended permissions:

• exec
• change location
• change state
• change perms
• change owner

It’s worth noting that the product maintains versioned copies of each content object, making it very easy to revert to any previous saved edit or simply review prior content.

Somewhere along the line we were told “at its core you get a document management system.” And then we saw a demo of the product working as a document repository. The demos showed a content author “checking out” a Word file via the browser, downloading it for editing, then checking the edited version back in, entering metadata and version info, and viewing the changed document in the repository.

APIs?

• Web Development Kit
  — Java apps that create the content authoring/management interface
• Documentum Foundation Classes
  — C++ API that runs the show

There are no SOAP or other webservices-based APIs, and it didn’t seem like there was much movement toward them.

Implementation?
A claimed three to six month implementation process including four or more weeks of service from SCT.

cms, lcms, sct, sungard, luminis, luminis cms, content management system, sungard sct, luminis content management suite, content management, web content management, demo, sales demo

With 1,800 CMS vendors in the marketplace, we’re mining what we know or know-of as a way to shorten the list. Kim named the following four:

• Joomla, a derivative of Mambo
   
• Collage appears to have good content reuse features
   
• OmniUpdate has a good list of higher ed clients
   
• Drupal: open source and turning heads

cms, content management system, joomla, collage, omniupdate, drupal, commercial, open source, oss, web, web management

We’re looking at the Sungard/SCT Luminis Content Management Suite (sales video). The real demo comes later, but the sales rep thinks Pima Community College and Edison College show it off well. Hmm.

cms, lcms, sct, sungard, luminis, luminis cms, content management system

CMS Market Watch tells us that there are 1,800 CMS vendors, and some of them are getting a little feisty.

cms, content management system, content management systems, vendor, vendors, 1800, cms vendors, feisty, marketplace, competition

Everybody wants a content management system, but there’s little agreement about what a CMS is or what it should do. Even knowledgeable people often find themselves struggling for an answer before giving up and defining a CMS by example.

The problem is that we know we want better websites, and we know technology should help, but how.

Jeffery Veen offers some sage advice to those who would ignore the non-technical facets of the problem:

Over and over I’ve heard the same complaint about [CMS implementations], “Turns out, after all the budget and time we spent, we really didn’t need a content management system at all. We just needed some editors.”

That is, software can’t build good websites. The web lives on text, well written text, and that has to be at the center of any CMS project. Veen’s suggestion that companies put more editorial staff on the job may seem at odds with my own recommendations that companies encourage blogging and distributed authorship, but I see them as complementary. Every site needs strong leadership, editors, not web designers, should be driving that.

Still, organizations go looking for software solutions to the problem. Big name commercial solutions in this space include Vignette, Broadvision, nCompass, Interwoven, and Open Market Content Server, but all of these six-digit price-tag CMSs appear to suffer a gap between buyer’s expectations and actual product functionality, according to Shorewalker.

Among other salient quotes from Jupiter Resarch reports on CMSs, the Shorewalker story offers this:

Today, more than 60 percent of companies that have deployed Web content management solutions still find themselves manually updating their sites…

That’s a huge risk for a product with such a high price tag, but where Shorewalker’s story rings my bell is here:

[T]he real cost isn’t in the box of software. It’s in the cheques you write to the people who install, adapt and maintain the software.

Remember, the cost of any software product is be broken into three categories: acquisition, integration, and maintenance. Some product categories have relatively low integration costs, but CMS are too immature and our needs are too diverse to be among them. And this is why home-grown and open-source CMS solutions are worth a good look: you may have to invest more on integration, but the result will probably be better than with a commercial product, and the total investment will most likely be lower because it eliminates the acquisition costs.

tags: broadvision, cms, cms pitfalls, cms project, cmss, commerical vs. open source, content management, content management system, editorial authority, interwoven, pitfalls, vignette, web content, web designers, web site management

WordPress’s Pages open the door to using WP as a content management system. Unfortunately, Pages can’t be edited via XML-RPC blogging apps like Ecto. This might be a good thing, but I’m foolhardy enough to try working around it.

Here’s how:

Find a text editor you like and open up the wp-includes/functions-post.php file.

in the wp_get_recent_posts() function, change this:

$sql = “SELECT * FROM $wpdb->posts WHERE post_status IN ('publish', 'draft', 'private') ORDER BY post_date DESC $limit”;

to this:

$sql = “SELECT * FROM $wpdb->posts WHERE post_status IN ('publish', 'draft', 'private', 'static') ORDER BY post_date DESC $limit”;

Now, in the wp_update_post() function, look for this block of code:

// Escape data pulled from DB.
$post = add_magic_quotes($post);
extract($post);

and insert this block underneath it:

// XML-RPCs apps can't return “static” post status,
// so we have to work around it
$page_status = NULL;
if($post_status == “static”)
$page_status = “static”;

And follow that up by looking for this block:

// Now overwrite any changed values being passed in. These are
// already escaped.
extract($postarr);

and insert this block underneath it:

// set post_status static if this is a page
if($page_status)
$post_status = $page_status;

Fair warning: this works in my limited testing, but don’t blame me if you try it and it breaks something. You’d be a fool to mess with this on a live install, so don’t.

tags: blog, blogg as cms, blogg as content management system, blogging, cms, content management system, ecto, hack, hacking, hacking wordpress, php code, wordpress, wordpress hack, wordpress hacks, wordpress pages, xml rpc, xmlrpc

A friend and I have been talking about what it would take to turn WordPress into a CMS. We both have our doubts, but today I found this job ad that suggests we’re not alone in at least thinking of the possibility.

Needed: Web Designer/Programmer For Our Sites

We’re growing very fast, and have outgrown our current CMS and design. We’re looking for a designer and/or programmer to redesign our rapidly growing network and implement a CMS that ties it all together. The network includes our planned ContentNext hub, paidContent.org, MocoNews.net, and ContentSutra, along with BillboardPostplay, our joint venture with Billboard. In addition to redesigning the front end, we’re migrating all of the sites to a common platform with an integrated database. Our preference is WordPress with enhancements to make it more of CMS; we’ve also explored Drupal as a CMS and we’re open to another open-source CMS if it can achieve our objective. We’re planning a mid-fall relaunch.

In addition to WordPress, the right person/team will be well versed in PHP, web standards, MYSQL and experienced in deployment of multi-site content networks as well as taxonomy.

We are not averse to a team consisting of a lead developer with high-level experience and a person or persons with less experience as long as it doesn’t affect our timeline or the quality of the project.

Contact me, Rafat Ali, with your portfolio/skills and we can discuss further.

Anyway, I forwarded this to Zach with the subject: “affirmation.”

tags: affirmation, cms, content management system, content networks, job ad, wordpress, wp

I’ve been slowly struggling with the question of how to replace pMachine, my CMS engine here. I haven’t really liked any of the alternatives that others I know are using (link link link link), though I’ve been hard pressed to identify exactly what my complaints are. Among the points in Making A Better Open Source CMS, Jeffrey Veen names a few of the most frustrating for me: hard-coding of site layout in the CMS, mixing of content with site administration in the interface, and, sometimes, lax security.

He had spent some time at OpenSourceCMS, which allows anybody to fiddle with a variety of CMS installations without the time and trouble of figuring out how to install and configure them.

What I experienced was obtuse and complex software that was packed with gratuitous features at the expense of usability and user experience. It was software written by geeks, for geeks. This whole category of software desperately needs to be redesigned with writers, editors, designers, and site owners in mind.

…which is about exactly what my complaint against PHPNuke is. While he doesn’t actually identify anything that he’d recommend, I’m glad to know I’m not alone.

Update: of the four sites offered as examples above, three have switched to WordPress.

tags: cms, complex software, geeks, hard coding, http, lax security, open source, phpnuke, pmachine, switched, usability, wordpress