mikejcorey.com

Google Maps API hands-on training, part 2

mike — Wed, 10 Mar 2010 04:39:58 +0000

Go back to part one of the training.
Assumed knowledge:
HTML
Moderate to advanced Javascript understanding
CSS
XML
Google Maps API basic skills:

Initialization of map
Adding map controls
Basic adding of points, click event listeners
Display of map points from flat XML

Supporting files:

Starter file, with a basic map, for you to follow along: googlemapstartfile2.html
XML file, which you will want to have locally so you can modify it: basicmapxml.xml
Completed file, if you’re stuck or just want to skip ahead: googlemapspart2-complete.html

Dynamic geocoding

Users often will want to figure out how your data relates to their own geographic location. They want to search against an address or by clicking on a point on the map. To do this kind of functionality you’ll need to use Google’s gecoder function.
1. Create an instance of the geocoder to use for your searches. This should be placed in the code outside of the function that you use to create your map so you can use it anywhere on the page.
```
var objGeocoder = new GClientGeocoder();
```
2. Now let’s put the geocoder to use. Whereas most of our actions are called against the map instance (objMap), in this case we use the geocoder. Lets do a really basic manual address query that in any real situation you’d probably collect from an HTML form. You’ll see that Google takes the address and returns a point — formatted as a lat,long pair — if it finds something, and returns as undefined if it can’t geocode the address. In this case, if it does find an address, we’ll center the map on that point at zoom level 10. This code goes INSIDE the loadMap function, after the map has been instantiated.
```
var strTestAddress = "Your address here";
objGeocoder.getLatLng(strTestAddress, function(objPoint) {
	if (!objPoint) {
		alert(strTestAddress + " not found");
	} else {
		objMap.panTo(objPoint,10);
	}
});
```
3. Another way to react to user activity is to ask Google for a lat-long pair based on a user’s click. This allows a user who doesn’t know the address for their desired location to still use a proximity feature. This involves applying an event listener to the entire map. When a user clicks on the map, we first make sure they’re not clicking on a marker. If they are, we let that marker’s earlier set click handler do its work and do nothing in our function. If it’s not a marker, we re-center the map and do whatever else we might want to. Often we’ll want to pass the geocoded point to another function.
```
GEvent.addListener(objMap, 'click', function(objMarker,objPoint) {
	if (objMarker) {
	}
	else {
		objMap.panTo(objPoint,10);
		var objNewMarker = new GMarker(objPoint);
		objMap.addOverlay(objNewMarker);
		objNewMarker.openInfoWindowHtml("Pssst, pass it on: " + objPoint);
	}
});
```

Polylines and polygons

Markers are the most commonly used overlays in the Google Maps API, but polylines and polygons are next. Polylines are familar to most Google Maps users from the driving directions feature, but you can use them for other applications. Polygons are useful for showing regions and other non-point data.

I know what you’re thinking: STOP! Please don’t think you can throw up a Google map showing all the counties in your state. It will be slow, slow slow — this is a major failing of the Javascript API to me, and is one of the main reasons we use Google Maps for Flash for complex polygon data.

That said, polygons used one at a time or a few at a time work well. Let’s start by drawing a basic line:
1. We’ll start by putting some points into an array:
```
var arrLinePoints = new Array();
arrLinePoints.push(new GLatLng(33.5081, -112.2047));
arrLinePoints.push(new GLatLng(33.5642, -112.1154));
arrLinePoints.push(new GLatLng(33.5608, -112.0042));
arrLinePoints.push(new GLatLng(33.5116, -111.9211));
```
2. Then we’ll spit those points back out as a line. We specify an array that’s the source of the points, the color of the line, the line width, and the opacity of the line (0.1 to 1):
```
var objMyLine = new GPolyline(arrLinePoints, "#446891", 3, 1);
objMap.addOverlay(objMyLine);
```
3. Polygons work much the same, except that the last point in the array should be the same as the first one to close the polygon, and you specify a color and opacity for the fill color in addition to the stroke color and opacity:
```
var arrShapePoints = new Array();
arrShapePoints.push(new GLatLng(33.4623, -112.1086));
arrShapePoints.push(new GLatLng(33.4632, -112.0382));
arrShapePoints.push(new GLatLng(33.4280, -112.0375));
arrShapePoints.push(new GLatLng(33.4285, -112.1075));
arrShapePoints.push(new GLatLng(33.4623, -112.1086));
var objMyPolygon = new GPolygon(arrShapePoints, "#446891", 3, 1, "#99C1D8", 0.2);
objMap.addOverlay(objMyPolygon);
```
Clustering markers

Many times you’ll have a lot of points that at wide zoom levels are too close together to distinguish. Using marker clustering is generally the best way to get around this. Google has built-in clustering functions, but we like one called ClusterMarker better because it has more flexibility. The approach works so well that we use ClusterMarker even when we’re not clustering icons because it makes it easy to trigger clicks to a particular point.

You can download the plugin here:

http://googlemapsapi.martinpearman.co.uk/downloads.php?cat_id=1

And read more about using it here:

http://googlemapsapi.martinpearman.co.uk/articles.php?cat_id=1
1. For today’s example, in your HTML document’s , import the Javascript file that contains the clustering functions.
2. Create a custom icon to be used as your clustering icon. Since this icon has a different size and shape from the other icons from part one, we won’t base this on the baseIcon we created earlier. This should be defined with your other markers, outside the loadMap function
```
var objGroupIcon = new GIcon();
objGroupIcon.image = "http://www.mikejcorey.com/nicar2010/images/severalicons-brown.png";
objGroupIcon.shadow = "http://www.mikejcorey.com/nicar2010/images/severalicons-brown-shadow.png";
objGroupIcon.iconSize = new GSize(41.0, 36.0);
objGroupIcon.shadowSize = new GSize(57.0, 34.0);
objGroupIcon.iconAnchor = new GPoint(20.5, 18.0);
objGroupIcon.infoWindowAnchor = new GPoint(20.5, 18.0);
```
3. Create a new ClusterMarker instance for your map. We’ll also tell ClusterMarker what icon to use to mark a cluster. We can also easily turn the clustering on and off by setting the second line to true or false. Note: For some reason my code display tags are freaking out after this point, so delete any backslashes in the code
```
var objMyCluster;
var arrMarkerStorage = new Array();

objMyCluster = new ClusterMarker(objMap, { clusterMarkerIcon: objGroupIcon });
objMyCluster.clusteringEnabled = true;
```
4. Instead of manually adding a marker using map.addOverlay, when our marker function runs each time we’ll push each marker into the array we just created.
```
function createMarker(objPoint,strHTML,strIconName) {
	var objMarker = new GMarker(objPoint,{ icon:strIconName });
	GEvent.addListener(objMarker, 'click', function() {
		objMarker.openInfoWindowHtml(strHTML);
	});
	arrMarkerStorage.push(objMarker);
	return objMarker;
```
5. Since the ClusterMarker is now going to handle the placement of markers, we can delete or comment out the line inside loadMyLocations that actually places the marker.
```
//objMap.addOverlay(objMarker);
```
6. Once our XML loop has finished running, we’ll tell cluster marker to go to work on the array of points we’ve stored up. Make sure this is outside and after your loop but still inside the loadLocations function.
```
objMyCluster.addMarkers(arrMarkerStorage);
objMyCluster.refresh();
```

Location-aware potholes map lives!

mike — Wed, 10 Mar 2010 02:07:51 +0000

We launched a beta today of our mobile potholes map, which features extensive use of geolocation using the user’s Web browser. This has been on my and James Wilkerson’s plate for a long time, and it feels really good to get at least this version out in the public.

The mobile site is at http://dmreg.com/potholes.

You can see the desktop browser version at DesMoinesRegister.com/potholes, and there’s more info on that project in a previous post.

This is our first extensively location-aware site, and it’s our first really extensive specialty mobile site, so there’s a lot of figuring out still left on this one. But we’re pretty happy with the result.

We used quite a few methods that were different or modified from our other mapping projects.

1. For geolocation, we’re using the W3C geolocation API built in to many phones’ browsers. Safari for iPhone and most Google phones have it, but BlackBerries don’t. Theoretically we’re also supporting Google Gears geolocation, but we haven’t really tested it on mobile devices.

2. We used the Google Static Maps API instead of the more-familiar Javascript API. The Javascript API actually works fairly well, technically speaking, on iPhones and Google phones, but the user experience can quickly become confusing. Dragging things on the map is hard on a mobile device, and zooming in and out on the map often messes with the browser zoom. The static maps API is a lot lighter load for a mobile connection to bear. Almost as a bonus, because I was about ready to write off the BlackBerry browser, using the static API also enables BlackBerry users to use the site (the lack of browser GPS still limits BlackBerry users, but they can at least submit a pothole using an address).

3. We’re using Prototype’s Ajax and JSON to load points and send new pothole data. We’ve done this a few times now, and it’s becoming our standard. JSON is lighter than XML on the server, and you can send data back and forth as Javascript objects, which makes sending complex data much easier (and much easier to modify later).

4. We did this as a website instead of an app in order to work with more platforms at once, and because we’re much better at Web design than objective C (which is to say I know not a bit, and learning will take a while). I’m curious to hear others’ thoughts on this, because I think most journalism shops are going to have a hard time making the economics of iPhone, BlackBerry and Google apps a pretty tough thing to make work. As long as mobile browsers keep developing quickly, I think this is probably the way to go for now, unless you can afford to build your own apps, have a lot more time to devote to one project than we do, or can afford to pay someone else to build them for you.

Check it out, let me know what works and what doesn’t.

Google Maps API hands-on training, part 1

mike — Mon, 08 Mar 2010 03:01:23 +0000

Go to part two of the training
Presumed knowledge:
HTML
Moderate Javascript understanding
CSS
Basic XML
What you’ll need:

A Google Maps API key (one per server, make an include)
A text editor
Some addresses or Lat-Long coordinates
Where to geocode points:
- geocoder.us
- batchgeocode.com (feed it a tab-delimited file of addresses, get one back)
A browser
Firebug is very helpful

Supporting files:

Starter file, with a basic map, for you to follow along: googlemapstartfile.html
Completed file, if you’re stuck or just want to skip ahead: googlemapspart1-complete.html

Getting started:

Make sure you’re using the API appropriately. The good news is that Google has very open terms, but be sure you understand the advertising caveat

Create a basic HTML page

Keep a tab open for the API reference at http://code.google.com/apis/maps/documentation/reference.html

Load your API key inside the of the HTML document

Inside your HTML body, create a target
for your map

Inside your document’s tag, write Javascript to initialize your map after the entire body of the document has loaded

var objMap; //A variable we declare early so our map is accessible outside the function that creates it.
//A function that loads when the HTML page is finished loading, which creates the map
function loadMap() {
	if (GBrowserIsCompatible()) {
		objMap = new GMap2(document.getElementById("map"));
	} else {
		document.getElementById("map").innerHTML = "There's supposed to be a Google Map here, but your browser isn't capable of showing it.";
	}
}

Set a center point (lat-long pair) and zoom level for the map
```
objMap.setCenter(new GLatLng(33.453814, -112.073239), 12);
```

Add this code to the tag of your HTML document to initialize the map once the body has finished loading, and to prevent memory leaks

Add a different map type, set the map to use that type

objMap.addMapType(G_PHYSICAL_MAP);
objMap.setMapType(G_PHYSICAL_MAP);

Add some controls to the map for zooming and changing the map type

objMap.addControl(new GLargeMapControl());
objMap.addControl(new GMapTypeControl());

A marker is one type of overlay. Other overlays include lines, polygons, and ground overlays. There’s several ways to add markers to the map. Let’s start with the simplest method, and add a marker to the map using the default icon.
```
//The simplest way to add a marker
var objBasicPoint = new GLatLng(33.453814, -112.073239);
var objBasicMarker = new GMarker(objBasicPoint);
objMap.addOverlay(objBasicMarker);
```

That’s fine if we don’t want too many markers and we don’t want them to do much, but as soon as you get over about 5 markers, this approach becomes impractical. Writing a function that can be called over and over is a good way to handle multiple markers. Inside the function we’ll also add an event listener to pop up a label (called an InfoWindow) when the user clicks on the icon.

//Our function for creating markers with event listeners
function createMarker(objPoint,strHTML,strIconName) {
	var objMarker = new GMarker(objPoint,{ icon:strIconName });
	GEvent.addListener(objMarker, 'click', function() {
		objMarker.openInfoWindowHtml(strHTML);
	});
	return objMarker;
}

//Adding a marker the more useful way, using a function
var objPoint = new GLatLng(33.479035, -112.047882);
var strWindowContent = "Barrio Cafe\
Azcentral.com raves: Superb Mexican food in a funky setting.\";
var objTestMarker = createMarker(objPoint,strWindowContent);
objMap.addOverlay(objTestMarker);

If you have more than one type of data you want to show on the map, you’ll want to use a different color or shape of icon. You can make custom markers with any .PNG image file with a transparent background. Photoshop will work fine, but Adobe Fireworks is even better for this. We won’t cover creating the icon image here, so we’re starting with an image that we know the pixel dimensions of. For this map we’re going to use two icons that are the same shape, but are different sizes. First we’ll tell Google some key information about both icons. We’ll declare these variables before our other functions and outside of those functions, so we can access the markers from anywhere in the script.
```
//marker definitions
var objBaseIcon = new GIcon();
objBaseIcon.shadow = "http://www.mikejcorey.com/nicar2010/images/shadow-stop.png";
objBaseIcon.iconSize = new GSize(19, 25);
objBaseIcon.shadowSize = new GSize(32, 25);
objBaseIcon.iconAnchor = new GPoint(9, 25);
objBaseIcon.infoWindowAnchor = new GPoint(9, 1);
```

Now we’ll define the different icons, which will be based on our baseicon, and put the icons into an array for easy reference later.

var objRedIcon = new GIcon(objBaseIcon);
objRedIcon.image = "http://www.mikejcorey.com/nicar2010/images/stop.png";

var objGreenIcon = new GIcon(objBaseIcon);
objGreenIcon.image = "http://www.mikejcorey.com/nicar2010/images/start.png";

var arrMapIcons = [objRedIcon,objGreenIcon];

If you want to load marker data from a database, or if you’d like to be able to easily change the markers, you’ll want to load markers dynamically from XML or JSON. In this example we’ll load multiple points from a flat XML file. This process uses a custom asynchronous request from Google called GDownloadUrl.
```
//function for retrieving list of points from XML
function loadMyLocations(strWhichXML) {
	GDownloadUrl(strWhichXML, function(data) {
		var objXML = GXml.parse(data);
		var objLocations = objXML.documentElement.getElementsByTagName("location");

	});
}
```

Set up a basic Javascript loop to get each XML row

for (var numI = 0; numI < objLocations.length; numI++) {
}

For each row, get the attributes you need and run our marker function as before

var objLocationItem = objLocations[numI];
var numMarkerLabel = objLocationItem.getAttribute("label");
var numMarkerIcon = objLocationItem.getAttribute("markertype");
var numMarkerLat = parseFloat(objLocationItem.getAttribute("lat"));
var numMarkerLng = parseFloat(objLocationItem.getAttribute("lng"));
var objPoint = new GLatLng(numMarkerLat, numMarkerLng);
var strWindowContent = "" + numMarkerLabel + "\";
var objMarker = createMarker(objPoint,strWindowContent,arrMapIcons[numMarkerIcon]);
objMap.addOverlay(objMarker);

That’s all for part one. Here’s the code for the entire page:



	
	My awesome first Google map

Go to part two of the training

Frustrated with all things BlackBerry

mike — Wed, 03 Mar 2010 04:01:46 +0000

This week I’m getting to sink my teeth into one of my big priorities for the year: building mobile websites.

Yes, websites and not apps. I’d love to be building phone apps as well, but for now in the interest of speed we’re going with Web pages before apps. (Not that we’re not working on apps either, that’s just a separate topic.)

The good news for most Web designers is that building basic mobile websites is easy: Just write really simple HTML. You can use all the PHP you want since it’s server-side (insert also ASP, Django, your server-side secret weapon of choice). Ems are your friend in mobile Web design: Yes, you finally have to actually use them.

So far this year we’ve knocked out really simple mobile pages for state high school wrestling tournament results and for state high school basketball tournament scores.

As you can see, nothing fancy, but they look pretty, and they work on pretty much every mobile browser we tried them on, smartphone or no.

These were also a bit of R and D for the one I really want to build, which is in progress now: a mobile, location-aware version of our potholes map.

This one is a lot more technically complex, as you might imagine. And as soon as I started researching and testing, I hit a big snag: BlackBerries.

We want to use basic Google Maps API features, so we have to use Javascript and Ajax. Right there is a big problem: Even the newest BlackBerry browsers don’t work with the Google Maps Javascript API.

We also want to include Facebook Connect integration, but the Javascript method won’t work for that on BlackBerries either (to be fair, it’s pretty buggy on iPhones and Android as well, but the FBML all renders, and you can log in with Javascript).

Location awareness in the browser? No problem on iPhones and Android, as long as the phone has GPS. Not so on most BlackBerries.

So that makes three dead-ends today. I figured I could at least download the BlackBerry simulator and figure out what type of site I COULD make work on a BlackBerry with the Google Static Maps API. (This would certainly work, but no moving the point once it’s geocoded, which would be an issue for our purposes)

Oops, the simulator is for Windows only. Does RIM really think there’s only a few Web developers using Macs? Is it even a majority using Windows?

So I’ll just download the simulator on my Virtual Box and run it from there, right? Only if I want to spend 5 minutes waiting for the simulator to actually run, only to give me a connection error and not show any sites when I DO get the browser running.

I. Give. Up.

So can Web developers afford to ignore BlackBerry? Well, not probably not completely, but luckily the number of BlackBerry browser users is heading the in the right direction.

Comscore reported in December that from September 2009 to Dec. 2009 RIM browser market share fell by one percentage point, while mobile Safari was up 1.2 percentage points. Google mobile browser share was up 2.7 percentage points. Yes, RIM still had 41.6% of the smartphone marketshare, but that’s not so much more than iPhones and Google phones combined: 30.5% in December, and certainly still going up.

And my (admittedly unscientific) research with BlackBerry users in our newsroom seemed to indicate that people with BlackBerries aren’t as interested in Web usage as their Google- and iPhone-toting colleagues. They don’t seem to expect the same degree of neato interface/experience.

In any case, our options for mobile potholes:

1) Build two mobile sites, one for iPhones and Google, and another for BlackBerries. Do you want to build 2 sites for everything? Me neither.

2) Build for the browsers that work (OK, not fair, but it’s not like the Google Maps Javascrip API is new), on the theory that you’re offering the people who DO care the best experience you can, and that the number of people with access to the best features is rising all the time. And maybe BlackBerry will get its act together.

Neither are great, but for now I think I have to opt for 2. Sorry, BlackBerry friends! But I’d love to hear your thoughts. Am I way off base on the “BlackBerry users aren’t after great Web experiences” theory?

Am I missing the magical secret to BlackBerry Javascript development?

New project: Killing potholes with user input, local government support

mike — Sat, 27 Feb 2010 04:22:18 +0000

Project link: DesMoinesRegister.com/potholes

HTML/Javascript/Facebook Connect Development: Michael Corey
Database backend/Local government admin: James E. Wilkerson

UPDATE: Mobile, location-aware potholes beta map now launched!

In case you haven’t noticed, potholes are everywhere. We hate ‘em, and we’re out to kill them.

We did a similar map two years ago, but there’s a few big twists that make us pretty proud of this one.

Working with local governments: We consulted extensively with Des Moines Public Works to see how we could build a system for reporting potholes that worked for our users AND for the city. We sent them data last time as well, but it didn’t work well for them. We didn’t have reverse-geocoding figured out two years ago, and someone had to re-enter our data into the city’s system to make anything happen.

Neither side wanted a repeat of that, but we really wanted to build a system Des Moines would actually use. The result: We send them daily e-mails with Excel attachments showing new potholes with exact locations. They’ve told use they’re going to hand those spreadsheets directly to their road crews and use that as a manifest for the day alongside their existing system. We’ve gotten word from several suburbs that they’ll participate as well.

As far as I know this is the first time we’ve ever pushed data TO a government agency. Usually we’re trying our best to pry it loose from them. And we think this is a pretty big win-win. We have a larger megaphone than the city Web site, and they have the power to make the evil potholes go away.

Facebook Connect support: This is our first Facebook Connect app. We’re giving users the option of logging in with their Facebook ID or their DesMoinesRegister.com account. We wanted to add registration of some kind this time around to cut down on spam and to see how willing people will be to use their real ID on our site.

We’re only scratching the surface of what we can do with Facebook Connect, but hey, we launched this thing today. Give us a bit. Lots more to come.

Geo-awareness: We’ve enabled browser-geolocation if the user chooses, so she can mark a pothole near her current location. This isn’t incredibly useful for desktop users, but we’re adding a mobile version soon, and we all know that’s where the real geolocation action is.

The early buzz on Twitter in response to the launch has really been good. And this is the first time I’ve been happy about the worst winter in my recent memory: there won’t be a shortage of potholes to fill this spring.

Denmark photos!

mike — Sat, 28 Nov 2009 02:55:25 +0000

Lots of photos from my trip to Denmark are now posted!

Highlights include Koldinghus:

Tivoli at Jul, with København city hall in the background:

Smørrebrød in Amagerbro:

Danmark, farvel

mike — Wed, 25 Nov 2009 08:32:12 +0000

I’m waiting groggily (not the Tivoli kind of grog) and a bit grumpily for my flight out of København. I’ve had a great time in Denmark and will have a lot more to say in the next few days, but for now anything I post is going to be more unintelligible than me trying to say “rød grød med fløde.”

So an early thank you to everyone who made me feel so welcome here. I miss home, but it’s very hard to leave. Hopefully we’ll all meet again soon.

Danmark, her kommer jeg!

mike — Wed, 11 Nov 2009 01:56:52 +0000

Hello, Denmark visitors! I can see some traffic coming in from the GeoForum site, and rest assured, I’m plugging away and putting the finishing touches on my presentation for Kortdage 2009 in Kolding next week.

I’ll be talking about the use of Google Maps in journalism, and it should be a fun talk. In any case it has been fun for me to go back over the last few years of work and see how far we’ve come.

And of course I’m extremely excited to be visiting Denmark. Many thanks in advance to GeoForum Danmark and especially to Jesper Ishøj, Hans Ravnkjær Larsen, Lars Brodersen and more for helping to bring me across the Atlantic. I’m excited to learn more about Danish history and culture, and I’m especially looking forward to meeting some of the innovators in Danish neocartography and journalism.

Those who know me well also know how excited I am to have the opportunity to see a European football match while I’m there between Bronby and OB, two of Denmark’s top teams. Someone be sure to tell me what colors not to wear before we go!

Guatemala project wins national APME award

mike — Wed, 21 Oct 2009 02:38:54 +0000

I haven’t done a full project posting for this one yet (it’s a bit older than this site), but clearly I’m going to have to now: The Des Moines Register’s Guatemala: Hope At Any Cost project is a winner of this years APME International Perspectives award.

Register reporter Tony Leys and Register photographer Arturo Fernandez traveled to Guatemala in October 2008 to gain another perspective on a large immigration raid at a Postville, Iowa meatpacking plant in May 2008. The raid was unusual, in part, because federal officials pressed identity theft charges that landed longer prison sentences than many of the workers likely would have expected.

Tony and Arturo went to Guatemala to get a glimpse of the life that many of the workers had left and were now returning to in Guatemala after serving their prison terms.

I love working with Tony and Arturo: Both of them always turn in top-notch work that challenges me to do a presentation that’s up to the task of showcasing the beautiful and moving photography and words they produce.

The story they brought back was desperation: the Guatemalans who traveled to Iowa knew they were gambling with their families’ wellbeing in coming illegally to the United States. When they landed in prison, rather than being simply deported as is often the case, their families were suddenly cut off from a major source of income and put into an even more dire financial situation. But people from the same rural communities are still leaving for the United States, because things are so bad at home it’s worth the risk.

I’m really glad to see the project get the attention it deserves – congratulations to Art, Tony, and to everyone else involved!

Buddy Holly, Parkersburg projects win regional Emmy awards

mike — Wed, 21 Oct 2009 02:16:59 +0000

It’s been a long time since I’ve posted, but I can’t forget to mention the biggest news of late: The Des Moines Register took home two regional Emmy awards last month!

Buddy Holly: 50 Years After the Crash That Changed Rock ‘n’ Roll won in the Advanced Media Documentary: Historical-Cultural category. More details on the project here.

The Falcons Rise Again won in the Advanced Media Sports category. More details on the project here.

I know what you’re thinking: REGIONAL, right? It’s the same Emmy program, we really did get two of those cool statues, and were up against some serious competition. No other Iowa media outlet had two Emmy awards this year, and we won two as a newspaper site against mostly television stations.

It’s great to work with the quality of people who make awards like this possible. The Falcons Rise Again video was very much the work of Todd Bailey, who unfortunately left the Register earlier this year. I definitely miss the luxury of knowing that when Todd is working on a project I’m going to get a pitch-perfect piece with a great understanding of the tone we need.

The Buddy Holly project was a collaborative effort among a lot of great people that was more than a year in the making. We’re really excited and a bit surprised that we got to be honored for it.