Useful features:

• Bulk tag delete and rename, including tags listed by popularity
• Tag grouping, which allows you to add a tag that encompasses other tags
• Auto-tagging, on post-save or en-mass

While it takes some time to clean up a tag space, it’s at least possible now.

SELECT *
    FROM wp_terms AS t 
JOIN wp_term_taxonomy AS tx 
    ON t.term_id = tx.term_id 
JOIN wp_term_relationships AS tr 
    ON tr.term_taxonomy_id = tx.term_taxonomy_id 
WHERE taxonomy = 'category' 
GROUP BY t.term_id
ORDER BY count DESC, t.term_id;

The new taxonomy approach introduces the possibility of displaying better clusters of categories, by including tags in the mix. It also cleans up the SQL from the previous releases with simpler ways of getting count and a clearer relationship mechanism. The table design is clean too, a big improvement over past schemas.

1. Of course, you would use the public category/taxonomy APIs if this was all you needed

With each day’s build, Microsoft is running a battery of automated tests against around 1,000 of the leading software programs. It has written 750,000 lines of code just to create the test patterns, which take 355 servers the better part of the day to run.

^(?:\s+|)<(\w+)(?:\s+|)((?:.*?|))>(.*?)(?:<\/(.*?)>|)(?:\s+|)$

This expression parses a line that contains HTML tags based on the following logic, expecting that:

1. There will be a start tag near the beginning of the line, possibly padded on the left with spaces that are ignored
2. The opening tag may contain some HTML parameters
3. There may be a closing tag on the line
4. There may be spaces on the right of the closing tag that will be ignored

The expression will parse the following example into 4 parts:

<h1 id="test">This is a test</h1>

1. h1
2. id=”test”
3. This is a test
4. h1

Learning regex to the point of being able to write complex expressions has taken a couple of years, but has been well worth the effort. To define the same parsing logic in C or C++ (using standard mechanisms) would take 20-30 minutes, and would occupy a page of code. You just have to remember that a regex is a small script, and that it should be tested (and documented) like one.

Regex is like a lot of little languages too (like SQL, bash, m4). It’s terribly useful, succinct, and worth having in your toolkit. It’s not something to hide in layers of abstraction either, rather it’s something that deserves use alongside your ‘real’ tools. I find that developers are in the habit of hiding (or hiding from) little languages, something that results in the too-many-elbows syndrome: insulating yourself from the real power of your tools, making things more complicated in the process.

Simple, in the end, is in the knowledge of the beholder. If you understand regex, code that contains it can be simpler.