Once the WordPress branch was set up on CVS, Mike and Matt started making changes. They were small and iterative, but they were the first steps that moved WordPress away from its predecessor and marked the real beginning of the project. Mike’s first commits involved repopulating files that were missing from the branch, while Matt added wptexturize, a tool he created to properly format plain text (straight quotes to curly quotes, for example, and dashes to em dashes). Mike’s first feature was the excerpt functionality which allows users to display handcrafted post summaries in RSS feeds and in other places.
Over the coming months, Mike and Matt made over 100 commits to the WordPress repository. Notable commits included WordPress’ branding, Mike’s b2links hack, which remained in WordPress until it was no longer turned on by default in WordPress 3.5 (released in 2012), major changes to the administration panel, and installation process improvements. Creating a simple installation process was something that both the developers felt strongly about. It was important that WordPress have a low barrier to entry. Anyone should be able to get on the web and publish their content. Matt replaced the
b2install.php file with a new
wp-install.php file. The aim was to keep configuration to a minimum. In the first version, the user had to create a MySQL database, add the configuration details to
b2config.php, transfer the files to their server using FTP, and then run the script. The “famous 5-minute install” was refined over time as the developers worked to simplify the process.
While developing WordPress, Mike and Matt were still active on the b2 forums, talking about the new software. But there were a few months after the WordPress project started when it was unclear which fork would be b2’s official successor. On May 23rd 2003, Michel announced that once WordPress was launched, it would become the official branch of b2.
On May 27th 2003, the first version of WordPress, WordPress 0.7, was released. Users who switched from b2 to WordPress got some new features, most notably the new, simplified administration panel and the WordPress Links Manager, which allowed users to create a blogroll.
Once WordPress 0.7 shipped, there was an effort to get other developers involved in the project, starting with Donncha Ó Caoimh and François Planque, both of whom had created their own b2 forks.
On May 29, 2003 Matt emailed Donncha to ask if he would consider merging b2++ with WordPress. Donncha agreed, raising the number of official WordPress developers to three. Matt also contacted François Planque to join the project and rewrite his b2evolution improvements for WordPress. François considered it, but felt that “it was too much work for too little benefit.”
Over the year, Dougal Campbell, (dougal) and Alex King joined the team. Although not a b2 user, Dougal had investigated using b2 for his blog, and had blogged about writing his own blogging software. Alex had been more actively involved in the b2 community — while he didn’t have a background in PHP, he learned it through the platform and the community. He particularly recalls Mike Little helping him refine and improve his code.
It took Dougal and Alex some months to get properly involved. Dougal was busy with work, and Alex’s first impressions of WordPress weren’t positive. He wrote about upgrading from b2 0.6 to either WordPress 0.7 or b2++. Installing WordPress didn’t offer any significant speed improvements, while b2++ gave him a site that he couldn’t log into. He decided to wait until the next version of WordPress to upgrade. Matt responded, noting that there would be significant improvements to database speed later on. WordPress 0.71’s release announced a 300% performance boost: “We’re not kidding,” the announcement post reads, “this release will perform about three times (or more) faster than previous releases of WordPress and b2.” It wasn’t, however, fast enough to convince Alex to upgrade. He and Matt kept in touch and in July 2003, Alex announced that he would help Matt launch a hacks section on WordPress.org.
In the early days, WordPress developed organically. A new developer’s first change tended to be a small, iterative step, before they worked on a pet feature. Most developers focused on web development areas they had an interest or a background in. Matt, for example, focused on semantics and usability.
Mike improved his b2 links plugin. He also introduced
wp-config-sample.php. At the time, all b2 and WordPress configuration information was stored in
b2config.php. This meant that upon upgrade a user had to store the file and information safely. If they overwrote it, their configuration information would be lost, and they’d end up on the support forums looking for help. Including
wp-config-sample.php meant that there was no
wp-config.php file bundled with WordPress — the user renamed the file
wp-config.php, protecting it from being overwritten. This configuration file protection was something Mike had done for previous clients, and while he recalls now that it seems like an obvious thing to do, it solved a problem that users had encountered repeatedly.
Dougal’s major focus was the XML-RPC API which, at that time supported Blogger’s API. XML-RPC is a remote transfer protocol, which allows for remote calls via HTTP. This means that the user can post to their blog or website using a client. The Blogger API didn’t cover all of the features that WordPress had. The Movable Type API and MetaWeblog API had additional features that built upon the Blogger API. Dougal added the new features so that the XML-RPC layer covered WordPress’ entire feature set. At the time, people would check their RSS feed over and over again and it would regenerate just like a pageview. This could increase the load on the server, slowing the site down. Dougal worked on improving these capabilities, speeding it up by including a cached version.
Alex’s first project was checking in a cursor-aware quicktag code. This enabled users to highlight a word in the text editor and use a hotkey to surround the text with HTML tags. In the end, the hacks section on WordPress.org that he had posted about on his blog was never built. Hacks were superseded by the plugin system.
In parallel to WordPress developments, Donncha worked on WPMU (WordPress MU). The original plan was to merge the b2++ codebase with the WordPress codebase, but they ended up remaining separate and b2++ became WPMU. WPMU had its own version control system and, eventually, its own trac instance. Donncha recalls that WordPress and WPMU targeted different audiences. “Most people just have one blog,” says Donncha, “they don’t have half-a-dozen blogs running on one server so multiple sites wouldn’t have been a requirement for most people.” Over time, this situation changed as it became easier and cheaper for people to host their blogs and websites, but in 2003, it didn’t make sense to have multi-user functionality available to every WordPress user. Instead, Donncha worked on WPMU alongside WordPress, and merged the changes from WordPress into WPMU. When a new version of WordPress was released, Donncha had to merge each file individually into WPMU. He used Vimdiff to load the two files side by side so he could review changes and push them from one file to another. It wasn’t always easy. “I had to keep track of the changes that were made in case they broke anything. So at the back of my mind I’d be thinking ‘did that change I made five files back, will that affect this change?'” As WordPress got bigger and bigger, the merges became more difficult to manage.
In late 2004, a now long-standing WordPress developer took his first steps into the community. Ryan Boren, (ryan), was a developer at Cisco Systems. Like Mike, Ryan is a big advocate of free software; he’d contributed to free software projects before, particularly Gnome and Linux. When he found WordPress, he’d been looking for a free and open source blogging platform. Ryan had been blogging for a number of years. His earliest blog posts were on Blogger, and then Greymatter, until he decided that he “wanted something new and a little nicer.” He liked WordPress’ markup and CSS, so he made the switch, scratching his own itch by writing a Greymatter importer to move his content to WordPress.
Almost straight away, Ryan had influence in the community, writing huge amounts of code and also providing advice on how WordPress development should be carried out. He had more free software project experience than anyone else at the time, and he was on forum threads sharing his thoughts on how things should be run. While he had little experience with PHP at that time, his coding background allowed him to quickly learn. It wasn’t long before he was given commit access to the WordPress repository.