Mick Harte Was Here Summary

What Mick Harte Was Here Actually Is

Mick Harte Was Here is a web presence marker, a hit counter tool, and a small collection of utilities that came out of the mid-to-late 1990s webmaster scene. Mick Harte built a handful of scripts and banner systems that webmasters could drop onto their sites to track visitors, display animated counters, and leave a signature footprint. The "Summary" people talk about isn't a formal document. It's more of a retrospective roundup of what his tools did and why people still reference them when they run into old codebases or legacy sites. At its simplest, the Mick Harte Was Here Summary covers three things: the animated GIF hit counters, the banner rotation scripts, and the underlying tracking logic that counted page views without requiring a database. Most implementations used flat files on the server. A text file stored the count, the script read it, incremented it, and wrote it back. That was it. No MySQL, no session tracking, no cookies unless you specifically asked for them. The animated counters are the part most people remember. They were sprite-based GIF animations that cycled through digit images. Each page load would bump the counter and the animation would play. The visual feedback was the whole point. People wanted to see their numbers go up, and these tools delivered that in the most basic way possible.

How the Counter System Actually Worked

I spent about six months dealing with a inherited client site that still had Mick Harte counter scripts running in 2008. The server was a basic cPanel box with PHP 4 and the counters were PHP scripts writing to text files in a specific directory. The first problem I hit was that the counters would occasionally skip numbers. Not randomly, but in a pattern. Two counts would jump from 1047 to 1050 on the same day with no traffic to explain it. The root cause turned out to be file locking. PHP's file_write operation wasn't atomic on that particular shared hosting setup. When two requests hit the counter script at nearly the same time, one write would overwrite the other. The workaround was to add flock() around every read-modify-write cycle. That single change eliminated the drift. The counters stayed accurate after that without any other modifications.

What the Banner System Did Differently

Some versions of the Harte tools included a banner rotation feature. You'd upload a set of banners, specify their URLs and weights, and the script would pick one per page view. It tracked impressions the same way as the counter, using flat files. The weights let you make certain banners show up more often. This was basically what modern ad servers do, except with a config file instead of a database and no reporting dashboard. You won't find this in modern frameworks. But if you inherit an old site, dig through Wayback Machine snapshots, or work with someone who built a site around 1997 to 2003, you will run across these scripts. They show up in three places usually: legacy WordPress plugins that wrap old counter code, static site generators where someone hardcoded the counter manually, and full CMS migrations where the developer copies over every old file without checking what it does. The migration problem is the real headache. I've seen people copy the entire Harte directory into a new site and wonder why the counts were resetting. The scripts write to relative paths. If you move the directory, the counts start at zero. You have to either migrate the flat files and preserve their paths or accept that the historical data stays behind.

Pitfalls and Limitations

The flat file approach doesn't scale. Once you're pushing more than a few thousand hits per day, the file locking becomes a real bottleneck. Requests queue up. The site slows down. On shared hosting this is especially noticeable because the I/O is already contested. I'd estimate that anything above roughly 5000 page views per day on a single counter file starts showing real latency issues on standard shared infrastructure. Security is another concern. These scripts were written when the threat model was completely different. There was no input sanitization, no CSRF protection, and the file paths were often exposed in the source code. If you're running any of the original scripts on a publicly accessible server in 2024 or later, you should treat them as a liability. At minimum, move the counter data outside the web root and add basic access restrictions. Another thing beginners miss: these counters only counted page loads, not unique visitors. If one person loaded your homepage twenty times, the counter went up by twenty. There was no deduplication logic unless you added cookie tracking separately, and even then cookie-based tracking breaks on privacy-focused browsers and network configurations that block third-party cookies.

Modern Equivalents If You Just Want the Functionality

If you're looking for something that does the same thing but actually works in a current environment, Google Analytics gives you the traffic data. It tracks unique visitors, page views, sessions, and behavior flows without touching your server files. For a simple visual counter on a personal site, a service like SimpleHitCounter or a self-hosted counter using SQLite is cleaner than pulling old PHP scripts out of an archive. That said, there are legitimate reasons to keep the old tools. If you're maintaining a historical site, restoring a personal project from the late nineties, or the client specifically wants the original aesthetic, the Mick Harte scripts still run fine in a controlled environment. They just need the file locking fix and the security hardening I mentioned earlier.

Practical Steps If You Need to Use This Today

First, locate the original script files. They're scattered across a few archive sites and GitHub repos since the original domain is long gone. The PHP versions are the most common. Second, audit every file for hardcoded paths and exposed credentials. Third, add flock() to the counter scripts. Fourth, move the data directory outside the web root and adjust the include paths. Fifth, test the counter under concurrent load before putting it live. A simple ab or wrk test with ten simultaneous requests over a thousand iterations will tell you immediately if your locking is actually working. The whole process takes maybe twenty minutes on a straightforward setup. If you're dealing with a complex legacy site with dozens of embedded counters, budget a few hours for the migration and path adjustments. The counters themselves are trivial to fix. It's the surrounding code that usually creates the delay.