In the process of taking up motorcycling this summer I also gained an additional hobby: scouring maps and travel guides to find the roads that would be most fun to ride. While I’ve had great times on dirt roads through farmland and wide open highways, there just isn’t anything that compares to the thrill of leaning through the corners on a winding road.

While I’ve had some good successes in locating roads by map (such as Tracy Road), one of the shortcomings of a map is the tight curves you can really lean into tend to be below the resolution for many maps. Atlases and electronic maps like Google Earth allow you to zoom in, but then there is the problem of finding the gems in the sea of data. What I realized I needed was a way to highlight just the most curvy roads so that I would know where to explore next.

For those less familiar with the intersection of cartography and software, the electronic mapping systems of the world (your Garmin/TomTom GPS, Google Earth, MapQuest, etc) have sequences of thousands of coordinates that linked together define the paths of roads across the surface of the earth.

While most of these systems use proprietary data sets, a service called Open Street Map (OSM) is a community driven project that anyone can add and edit — a Wikipedia for cartographic data. In some parts of the world the Open Street Map has better coverage than any commercial providers; in the US the original data was imported from the public domain USGS TIGER data set and has then been expanded and improved by the community. I’ve known this data was available for a long time, but it was only last week I realized that it would be possible to search through the coordinates that make up road-paths to analyze their geometry rather than just their position.

I can get the raw data from the Open Street Map for the path of every road, but how to determine which ones are the most twisty? At the beginning I tried a strategies such as calculating the ratio of distance traveled on a road versus the distance between the start and end points. Unfortunately all of these methods had situations that confused the algorithms (such as circular roads) or didn’t distinguish between fun curves and boring broad changes of direction that would only be exciting at far beyond the speed limit. What I eventually came up with is a process of calculating the radius of curvature at every segment of every road and then adding up the length of the most curvy segments to get a total distance spent turning. The twistier the road, the more time spent turning.

I’ll get back to more of the details in a bit, but I ended up writing a small program that reads through the Open Street Map data and spits out KML (Google Earth) files that highlight just the twisty roads. This program is called curvature.py and is available on Github here: https://github.com/adamfranco/curvature/wiki

When running curvature.py you can pass a variety of options that allow you to highlight the roads you are most interested in. For example if you live in the flat Midwest you can pass it a low curvature threshold to try to locate roads that have any curves. Give it a medium threshold and the output can help you find a more interesting route to work. Similarly if you want to find just the most absolutely crazy-curvy roads in a region give it a high threshold to filter out wheat from the chaff.

With the --colorize option, KML files will be generated with each road segment color-coded to match its curve-radius. Green segments are above the threshold considered “straight”, while yellow are broad curves, orange tighter, and red tightest:

More about calculating the curvature

Each way (road) is made up of a sequence of points defined as a pair of latitude and longitude values. Each sequence of three points makes up a triangle where two of the sides are road segments with a hypotenuse between the 1st and 3rd points. Since we have the latitude and longitude of each point we can easily calculate the distances between them, but figuring out what the curvature of the road is at this set of points is a little tricky. Since the points aren’t evenly spaced the angle between the three points doesn’t tell us anything. Instead, we must go back to the geometric relationship that says for every triangle there is a circumcircle that intersects its three points. Using the equations for the circumcircle, we can plug in the distances between the three points and come up with the radius of that circle. That circle’s radius corresponds to the radius of the road’s curve at the middle of the three points.

Here is a video explaining the process:

Using Curvature
The Curvature Examples page shows a number of examples and provides links to KML files that you can open in Google Earth. If you’d like to just view curvature KML files that I’ve generated, you can find them at: http://www2.adamfranco.com/curvature/kml/

While all 226 pages are worthwhile, I found Section 2.13  “Land Use – Conservation and Development Plan” to be especially moving. I mean “moving” in a totally serious, non-ironic way. Coming from a town (Carlisle, PA) with rampant “Miracle Mile” commercial development and suburban sprawl, this forward-looking vision of how the town should be developed and improved in coming decades reassures me that 30 years from now Middlebury will be an even better place to live than it is today.

My favorite quote is from Section 2.13, page 151:

A fundamental objective of this Town Plan is to maintain Middlebury as a traditional Vermont town and to prevent incremental change to “anywhere USA”. This is not merely an aesthetic notion, it is a recognized economic development strategy for Middlebury and Vermont. This Plan supports architecture that is designed to fit its context in Middlebury and does not support standardized trade-marked or corporate prototypes.

In 2005 James Howard Kunstler (author of The Geography of Nowhere among other titles) gave a great talk at Middlebury College on human-scale urban development and the lack thereof in much of American urban planning. In his talk he justly derided our own little “Miracle [1/2] mile” by the Hannaford Shopping center. As an avid bicycle commuter who lived south of the village for many years I felt the effects of this poor zoning and development planning on a daily basis as I tried to safely navigate the no-shoulder/no-sidewalk turning-lane and fore-court infested section of road without getting killed. I am very pleased to see that slowly remedying these past lapses is part of the town’s plan for the future.

In addition to spending several hours reading the 2012 Middlebury Town Plan, I heartily recommend taking another hour to watch William H. Whyte’s The Social Life of Small Urban Spaces – The Street Corner. My favorite part is at 12:00: “People tend to sit where there are places to sit.”

My family has a small cabin on a lake in northern Michigan where I every summer growing up. Since moving to Vermont 14 years ago my attendance has slipped somewhat as the trip lengthened to a driving time of 15-17 mind-numbing hours along the flats of the New York Throughway and various mid-western highways. That said, I still try to make it to the lake at least once every few years. Since I took the full month of July off from work I figured I’d make the trip via motorcycle this time and learn if this sort of travel was for me.

To keep things interesting I planned a route out that would avoid expressways as much as possible and give me a chance to see the landscape of central Ontario — a region I haven’t seen before.

Total distance: 1077
Total moving time: 23 hours, 17 minutes
Average speed: 46 mph

View Larger Map
Key: blue line – planned route, red line – actual route

I planned the route with Google Maps, first starting with the default route, then dragging it onto the most twisted and windy back roads that I could find. After establishing a route I tried to break it up into chunks of around 6 hours to give myself plenty of time to wait out passing thunderstorms, deal with break-downs, and just get into each town early enough to do a little sight-seeing. The process worked quite well, but one limitation I found was that Google Maps doesn’t indicated the road type or surface for small roads. For example, about 20 miles of roads that I picked turned out to be dirt — not a problem as I thoroughly enjoy dirt roads, but it would have been nice to anticipate that better and might have been a problem if I had picked many more of them.

After planning out my route and making reservations at motels for each night I punched the routes into my GPS (Garmin Nuvi 765) with enough “via-points” to keep the automated routing on my desired roads. Much of the time I can’t really see the Garmin’s screen while I’m riding because of glare, so I run an extension cord from the Garmin’s headphone jack back to my in-ear headphones (MEElec M6P) which double as my hearing protection. In this way, I get nice voice prompts for turns without being visually distracted by the screen. Much of my route didn’t have any mobile phone service and using roaming mobile data while in Canada is stupid expensive ($15/MB) so using my phone’s navigation app was out of the question.

Day 1: Weybridge, Vermont to Sharbot Lake, Ontario

Distance: 300 miles
Moving Time: 6:45

I decided to make my first day the longest one since I was fresh and roaring to go on Tuesday, July 3rd. My route took me straight west across the Champlain Valley and across the Adirondack Mountains to Watertown, New York and from their north across the St Lawrence River and into Ontario.

The first hour of riding included my favorite road ever: Tracy Road near Moriah, NY. Tracy road has more than 50 curves over 7.5 miles as it winds around hills and beaver ponds in the Adirondack foothills. It was a total blast and a great way to start the day. The next few hours of riding were pretty spectacular as well (though not a twisty) as Routes 73 and 3 wound through the Adirondack Park past many clear lakes surrounded by hills and mountains.

After exiting the Adirondacks I made a quick stop in Watertown, NY before heading into Canada. I was pleasantly surprised at how charming and bustling Watertown was — I had expected something more “rust-belt” than the vibrant downtown I found.

I crossed into Canada via the Thousand Islands Bridge. The Thousand Islands are a place I will need to return to on a subsequent trip. The multitude of tiny islets with houses on them look so magical, though they are likely best explored by boat rather than road. Drove all over looking for an overlook, but could for the life of me find one. Dark skies threatened, so I gave up my search and headed for the border crossing.

Once in Ontario I headed straight north through the Land O’ Lakes region, specifically the Rideau Lakes and Frontenac townships. Much to my delight I found that most of the back roads in this area were unpaved. With light rain showers falling I enjoyed many slow miles through very scenic fields and forests.

I found the geology and geography of the Land O’ Lakes region fascinating. Basically, the landscape is made up of hard metamorphic rock that was the base of an ancient Laurentian Mountain Belt that formed 1 billion years ago. The mountains have since eroded away and recent glaciers from the last ice age have scoured and dimpled the landscape leaving an undulating surface of rock with very little topsoil. Because of the lack of soil, virtually every depression in the land is a rocky lake, pond, or bog.

The back roads and rural highways wound around these countless water bodies and eventually I reached the sleepy hamlet of Sharbot Lake, my first overnight stop.

I spent the night at the Sharbot Lake Inn, a sleepy little motel with a great view of the medium-sized Sharbot Lake. The proprietors were very friendly and when I mentioned that I might arrive late in the evening if I hit bad weather just said, “We close at 8pm, but we’ll put you in #7 and just leave the key in the door if you haven’t arrived by then.” The hotel was still open when I arrived but quite quiet on this Wednesday evening so after unloading the bike I walked across the street to the Maples Restaurant, the only establishment open past 9pm in this little town.

All in all the first day was a blast. The only hiccup I had was about an hour into the ride when one of my straps slipped and my kite/tripod bag rubbed on the rear tire for 1/4 mile and melted a hole in the outer bag and the kite bag. The tripod wasn’t damaged and the kite only had a small tear. To fix the problem I tied some loops in my main tie-down straps to give me something more sturdy to attach the bungee cords to:

Day 2: Sharbot Lake, Ontario to Parry Sound, Ontario

Distance: 269 miles
Moving Time: 5:31

I woke up Wednesday, July 4th to a beautiful morning with no hint of rain. After breakfast at The Maples I packed up and checked out only to find the battery dead and unable to start the bike. I assumed that it just needed to charge up, so I unpacked everything to get at the battery under the seat and got a jump from a friendly motel employee, and then packed up the bike while it was running.

The first back roads and rural highways of the morning were windy and beautiful, though one of the dirt roads narrowed to little more than a tractor track at one point. I was careful not to stall since I wasn’t sure how well I would get started again.

After about 40 minutes I needed gas, so I stopped at a tiny station in the middle of nowhere. Even after running for 40 minutes it was no closer to starting, so I unpacked again, got a second jump, repacked, stalled, unpacked, got a third jump, repacked, and headed 40 miles to the closest likely source of help: an Arctic Cat dealer in Cloyne, ON.

At the time I didn’t realize that motorcycle batteries required checking of the acid level and I must have let the battery go dry during the heat of the previous day and then further killed it while using it dry. The engine stalled as I pulled into Nowell Motors and one of their mechanics, John was able to find me a battery that fit. It wasn’t a perfect match, but it fit in the hanger and was my only option that didn’t include driving several hours in the wrong direction.

The battery was sorted out by about 1pm and from Cloyne I headed north along the Madawaska River to the Algonquin Provincial Park. Algonquin Park sits on a high rocky plateau that feeds rivers in all directions. Like the Land O’ Lakes region, it is full of many bogs and ponds at all stages of filling in with peat. Other than stopping briefly at the visitor center I drove right through the park and only paused for a moose sighting.

After the high forest of the park the highway descended down toward the rocky eastern shore of Lake Huron and the town of Parry Sound. While I had left myself plenty of time for riding on Wednesday, dealing with the battery had eaten up much of the morning and I arrived in Parry Sound just before sunset without too much time to explore. I checked into the Travellers Hotel in Parry Sound then spent the last moments of daylight wandering about the harbor. I had dinner at a nice restaurant by the harbor and then got to sleep early.

Day 3: Parry Sound, Ontario to Sault St. Marie, Michigan

Distance: 292 miles
Moving Time: 5:46

Thursday morning came bright and sunny again, though this time with an easy-to-start bike. After breakfast at the hotel I got on the road for a full day of driving on the Trans-Canadian Highway. I had hoped to get out and see a large part of the Georgian Bay coast, but the eastern shore of Lake Huron is full of more than 30,000 islands and many deep bays and long peninsulas. It turns out that the only way to get beyond a small sheltered bay would be to drive more than 45 minutes out a peninsula, then back the same way. There is really no coast road in this region.

I hoped to get to Sault St Marie early enough to do some sight-seeing, so I skipped on the Georgian Bay and kept to the highway. While parts of Route 69 and 17 (Trans-Canada Highway) are 4-lane expressway, the vast majority of the road was straight, flat, 2 lane highway with a third passing lane alternating directions every 5 miles or so. For the most part the landscape was forests, but one highlight was the French River Provincial Park where the French river drains Lake Nipissing into Lake Huron through a marvelous maze of rocky promontories.

By the time I reached the North Channel of Lake Huron near the town of Blind River I was finally able to get close to Lake Huron and too a small detour to get over to the lake. The shore here was finally more sandy than rocky, though still with bedrock sticking out hear or there. The landscape was generally pretty flat and houses and cottages dot the lake-shore drives.

After another couple hours of riding I came into Sault Ste. Marie, Ontario, a city of about 80,000 inhabitants and a very smelly factory near the river. The downtown was nice though and I did a lap around the downtown streets and waterfront before heading over the bridge to Sault St. Marie, Michigan — a much smaller town of about 15,000. While waiting to cross the border a fellow driver pointed out that my rear tire was bald… … and looked low. It wasn’t flat however, so I rode slowly the last 2 miles to my motel.

I checked into the Lockview Motel — a cute and cheap place right across from the shipping locks — and unpacked into my little 1-room cottage before looking at the tire. A bit of soapy water showed that there were three small punctures in the center of the tread, one from an unknown source and two from a staple. Since it was evening and there wasn’t much I could do I left the bike parked on its center stand and toured about the locks and their visitor center. Since no ships were coming through for a few hours I had a passable dinner at the Lockview Restaurant (the only thing open at 9:30pm). The walleye was tasty, but the rest of the meal (salad and mashed potatoes) were totally bland and flavorless.

By the time I was done with dinner two large ships were locking through the MacArthur and Poe locks, one going up to Lake Superior and one going down to Lake Huron. Both were bulk freighters that carry iron ore from ports on Lake Superior down to the big cities of the midwest and east.

Day 4: Sault St. Marie, Michigan to Beulah, Michigan

Distance: 216 miles
Moving Time: 5:15

I spent most of Friday morning calling around to several motorcycle dealers looking for a replacement tire. Since this bike has a somewhat odd size for its rear tire I struck out, but headed to one of the shops, Leitz Sports Center, to see if they might at be able to patch the tire or at a minimum have easier access to compressed air than I did at the motel.

The guys at Leitz were very helpful, but recommended against patching the tire since that might open a hole in the thin tread even more. Eventually, I ended up getting a can of the Slime “spare tire in a can” stuff and injecting it into the tire. With that and a top-up of air I was able to get on the road for the final 5 hours of the trip.

An hour or so into the trip I crossed the juncture of Lake Huron and Lake Michigan via the Mackinac Bridge and continued south to Petosky where I met up with my parents for lunch. Two more hours driving down the Lake Michigan and Torch Lake shorelines brought me to the end of the journey in Beulah.

While the tire and battery problems were certainly a hassle, they weren’t particularly unpleasant to deal with since I had left myself loads of extra time. Over all the trip was great fun and I’m looking forward to following it up with a similar journey on the way home. First though, I have two and a half weeks on Crystal Lake full of the rigors of reading novels on the beach, barbequing, and sailing. Its a tough life…

For the past two weeks our CSA share from the Gildrien Farm has included several cups of dried black beans, a food I’ve eaten many times but never really cooked with. In their weekly letter Jeremy and Caitlin helpfully included a recipe for Puerto Rican Black Beans, a tasty-sounding launching pad for the evening’s dinner.

Since I didn’t have any bacon grease on hand I figured I would just fry up several large pieces of bacon and use both the meat and the grease. I had planned to make a fritata as the main course for the evening, but after sampling the beans, decided to add some more veggies and put them on bread as our main course. Unfortunately, the result was so delicious that the crostini never made it out of the kitchen for a photo shoot.

Black Bean Crostini

• 1 cup dry black beans, soaked overnight
• 1 large onion, diced as small as possible
• 1/2 a red pepper, diced
• 1/4 lb of bacon (4-5 pieces)
• 1 cup of cherry tomatoes, quartered
• salt
• 1 baguette

1. Soak the beans overnight to soften, then simmer over medium heat for 45 minutes until tender.
2. While the beans are cooking, fry the bacon in a skillet over medium heat until it is crispy and most of the fat has melted off. Pull the bacon strips out of the pan and let cool, trying to keep as much of the grease in the skillet as possible.
3. Turn down the heat on the skillet to low. Add the diced onion and some salt to the bacon grease in the skillet and cook for 15 minutes, slowly letting the onion turn clear and caramelize.
4. Drain the majority of the water from the beans (leaving about a half cup) and add the beans and their water to the skillet with the onion and bacon grease. Stir together with the red pepper. Raise the heat to medium and stew for another 15 minutes or so, until the beans begin to fall apart.
5. Mash the beans in the skillet with a utensil of some sort until you have chunky bean paste interspersed with red-pepper and bean husks. Crumble the bacon and stir it into the beans. Salt to taste.
6. Cut the baguette into thin slices. Pile a large dollop of beans on each slice and top with diced cherry tomatoes.

The RiverLevels widget provides an easy way to monitor the amount of water flowing in your favorite streams and rivers right from your Dashboard. The RiverLevels widget is of particular interest to whitewater kayakers and canoeists.

Once any United States Geological Survey (USGS) stream-gauge station is selected, it is automatically refreshed to always provide you with the latest graph of the water-level. As of version 1.2 you can choose between two graph styles: discharge in cubic feet per second (CFS) and water-height in feet.

This widget is Free software, licensed under the GNU General Public License (GPL) version 3 or later.

• Download (alternate download link)

• More Info
• Apple’s Download page for RiverLevels.wdgt
• Bug Tracker

Requirements:

• OS X – 10.4 “Tiger” or later

Change Log:
1.2.2 (2011-03-23)

• Fix for image URL change in USGS site.

1.2.1 (2008-02-10)

• New zip archive includes the ‘library’ directory missing in the 1.2 release.

1.2 (2008-02-06)

• Fixed Leopard (10.5) compatability bug.
• Added the ability to choose Gauge Height (ft) in addition to discharge (CFS).

1.1 (2007-01-08)

• Fixed graphs extending off bottom of widget
• Fixed invisibility of front refresh icon

My current woodworking project is a Mission-style bookshelf that I designed to match the sofa table that I built last year. The bookshelf will sit below a window to the kitchen, so it is low and extra wide to fit that space. To support the weight of the books without sagging, sets of stiles transfers weight from the middle shelf to the frame above and below.

I am building the bookshelf out of cherry. Like the sofa table, all joinery is mortise and tenon. This time I am squaring out the mortises with a new set of mortising chisels rather than rounding off the tenons with a knife as I did on the sofa table — which is making the process go much faster.

If you like the design and wish to build one for yourself, you can download my SketchUp model as a starting point.

For example, here is the history of my drupal repository after some work updating the cas module to the latest version (and to support the new version of phpCAS):

As you can see, I have a number of commits, followed by a merge in with the new module code, followed by some more commits.

Now, if I merge my feature branch (master-cas3-simple) into the master via

git merge  master-cas3-simple

then the history will look like this:

While the history is all there, it isn’t obvious that all of the commits beyond “Convert MS Word quote…” are a single unit of work. They all kind of blend together because git performed a “fast-forward” commit. Usually fast-forward commits are helpful since they keep the history from being cluttered with hundreds of unnecessary merge commits, but in this case we are loosing the context of these commits being a unit of work.

To preserve the grouping of these commits together I can instead force the merge operation to create a merge commit (and even append a message) by using the --no-ff option to git merge:

git merge --no-ff -m "Upgraded CAS support to to cas-6.x-3.x-dev and phpCAS 1.2.0 RC2.5" master-cas3-simple

This results in the history below:

As you can see, merging with the --no-ff option creates a merge commit which very obviously delineates work on this feature. If we decided that we wanted to roll back this feature it would be much easier to sort out where the starting point before the feature was.

The tooling has involved a few challenges however, since Jasig (the organization that hosts the CAS and phpCAS projects) uses Subversion for its source-code repositories and we use Git for all of our projects. Now, I could just suck it up and use Subversion when doing phpCAS development, but there are a few reasons I don’t:

1. We make use of Git submodules to include phpCAS along with the source-code of our applications, necessitating the use of a public Git repository that includes phpCAS.
2. The git-svn tools allow me to use git on my end to work with a Subversion repository, which is great because…
3. I find that Git’s fast history browsing and searching make troubleshooting and bug fixing much easier than any other tools I’ve used.

For the past two years I have been using git-svn to work with the phpCAS repository and every so often pushing changes up to a public Git repository on GitHub. Our applications reference this repository as a submodule when they need to make use of phpCAS. Now that I’ve been doing more work on phpCAS (and am more interested in keeping our applications using up-to-date versions), I’ve decided to automate the process of mirroring the Subversion repository on GitHub. Read on for details of how I’ve set this up and the scripts for keeping the mirror in sync.

On my development server I have a git repository I’ve cloned from the Jasig Subversion repository via:

git svn clone --stdlayout https://source.jasig.org/cas-clients/phpcas/

I use this repository for my phpCAS development and am continually using git svn rebase and git svn dcommit to update my branches from Subversion and commit changes back to the Subversion repository.

My goal was to fetch from Subversion and push all of the branches and tags from the Subversion repository to GitHub while ignoring any private branches or un-dcommited changes I might have kicking about my development repository.

Step 1: Add the GitHub repository as a remote

git remote add github git@github.com:adamfranco/phpcas.git

Step 2: Fetch the latest changes from the svn repository
To do this, I just needed to run git svn fetch to import commits from the Subversion repository into my Git repository.

Step 3: Make Git tags for Subversion tag-branches
I may be doing something wrong, but it seems that Subversion tags come through git svn as git branches rather than as git “tag” objects. Basically they are a branch with a single commit that just adds the tag message, but no content change. Using git show I found I could grab the parent id, message, and other metadata from the “tag-branch”, then feed that into git tag to create actual tag objects in the git repository.

Step 4: Push subversion branches and newly created tags to GitHub
When called with no parameters git push will push all branches that have matching names in both the source and the destination repository. This wasn’t going to work for me since I want to only automatically push the branch-state that exists in subversion (not any un-dcommitted changes in my Git repository) and want to create mirrors of any new branches that appear in the Subversion repository. To accomplish this I needed to specify every branch individually. I determined the list of branches via:

git branch -r | grep -v '/' | grep -v trunk

then looped through them and appended them to the hard-coded mapping between the svn “trunk” and the GitHub “master”:

$cmd = 'git push --tags github refs/remotes/trunk:refs/heads/master ';
foreach ($svnBranches as $branch) {
	$cmd .= 'refs/remotes/'.$branch.':refs/heads/'.$branch.' ';
}

All together: update_github_phpcas
Below is a script which performs the tasks above. I’ve added it to my crontab so that it runs every half-hour and keeps my GitHub repository in-sync with the Jasig Subversion repository.

I think that this script should work with very few changes for mirroring any Subversion repository as a Git repository.

Above Bittersweet Falls, the Beaver Brook cuts a deep ravine through layers of black slate. The gorge can be difficult to traverse without getting one’s feet wet, but is filled with cascades and mossy bottoms ringed by ferns and overshadowed by hemlocks.

I headed out the door today planing to swing by Bittersweet Falls for a few quick shots before driving out to the Dead Creek Wildlife Management Area where stargazer05756 has been following the migration of snow geese. I never made it to Dead Creek. After taking a few shots below the falls I climbed up above and noticed an impressive gorge winding upstream. Ever since I was a child I have always loved exploring up cascading streams. There is just something magical above clambering around a rock to find another waterfall or quiet pool surrounded by moss, ferns, hemlocks — and in the south, rhododendrons.

The Beaver Brook didn’t disappoint and while its steep slate side posed a challenge, I hiked about a third of a mile upstream along the stream bed before scaling the hillside and quickly walking back to the car from above.

View Larger Map

The Northeast Waterfalls site has directions and more info.

gawk '{ print $7}' /var/log/httpd/access_log | sort | uniq -c | sort -nr | head -n 20

Parts of the command explained:

1. gawk '{ print $7}' — return only the 7th [white-space delimited] column of text from the access log, which happens to be the path requested.
2. sort — sort the lines of the output.
3. uniq -c — condense the output to unique lines, prepending each line with the number of times that line occurs.
4. sort -nr – sort the resulting lines numerically in reverse order.
5. head -n 20 — chop off all but the first 20 lines.

The result should look something like this:

  83361 /
  49582 /feed
  39616 /robots.txt
  36265 /favicon.ico
  17048 /?feed=rss2
  10798 /archives/3
  10036 /wp-content/uploads/2007/05/img_7870_header.jpg
   9913 /wp-includes/images/smilies/icon_smile.gif
   9425 /wp-comments-post.php
   8274 /feed/
   7508 /archives/category/work/feed
   7367 /archives/88
   7312 /photos/10_small/IMG_3023.JPG.jpg
   7175 /photos/10_small/IMG_3028.JPG.jpg
   7151 /photos/10_small/IMG_3024.JPG.jpg
   7096 /photos/10_small/IMG_3026.JPG.jpg
   6381 /photosetToKML.php?set=72157594417350372&size=small
   6253 /qtvr/2007-04-05_back_deck_snow%20-%2010000x5000%20-%20SLIN%20-%20Blended%20Layer0002.jpg
   5798 /photosetToKML.php
   4344 /archives/category/photography