Blog - MapMyGlobe

Yesterday we were linked to from Google Maps Mania which is one of the main directory for Google Maps mashups. Thanks to them! I hope this will help to make MapMyGlobe a little well-known

The post in question can be found here.

To celebrate my Thanksgiving vacation down in Mexico, I wrote a few pages about 3 of the places I visited over there.

So, you can now interactively visit the towns of Puerto Vallarta, Barra de Navidad, and Guadalajara. Hope this will help you set up your trip if you were planning to go there, or make you want to go if you weren’t.

In addition to the Map view, you can now set Satellite and Hybrid views on your pages. To keep it simple, the “Set center/zoom” button now incorporates the view type setting and is now labeled simply “Set viewport”.

The Satellite view, together with the transitions described in the previous post, allows some neat animations. You can try this one out.

I’m happy to introduce MapMyGlobe’s new feature: the ability to animate transitions between frames, i.e. to zoom or unzoom smoothly instead of just switching the viewport to a different location. Right now, this transition is computed from just the frames’ view centers and zoom levels, however, I don’t exclude the possibility of a finer-grained control by the user in the future. Until then, try it out, it’s pretty cool…

Actually, it looks like Google might be willing to roll out a similar user-generated animation feature in their MyMaps app as well. One proof of that being Mark Clark of Google’s London Underground map. He actually uses the same map.panTo() GMaps function that we do.

By the way, it looks like another huge trend might just have emerged at Google Maps/Earth. I’m speaking of the incorporation of imagery from the Southern California fires into Google Earth. As far as I know, it is the first time that Google’s imagery team publishes map tiles relevant to the news, at such a large scale, and as quickly as that. Which makes me think that at some point, any big event visible from the sky will be available on the web almost in real-time…

As a follow-up to the previous post, I felt the need for an overview of Collaborative Mapping applications, how they differ from MapMyGlobe, and why MapMyGlobe is better

A first category is made of apps whose goal is to collaboratively make map tiles, as opposed to annotating existing ones. This category contains some really cool projects, the most prominent being OpenStreetMap. These projects are very promising and sooner or later their data will be more accurate than traditional (non-User-Generated), commercial map tiles, and their API will be a huge competitor to Google and Live Maps. However as I said, we at MapMyGlobe are focusing on annotating current map tiles.

A second category of apps regroups projects that are technically very close of what MapMyGlobe does, but that can just not be called collaborative apps: in those apps, an individual creates a private map by annotating a provider’s map tiles, and either sends it to his friends, or makes it public, but viewers don’t have the ability to edit it. In this category are initiatives such as Wayfaring, and of course Google’s My Maps.

The third category is a subtle variant of the second one, where mappers don’t really add their own content to the maps, but rather link to other data sources. Contrary to the second category, most of these apps can be called collaborative, because everybody can usually add data from the data sources. Examples of such mashups include Panoramio, a Spanish app that enables pinning pictures on a map, and that was recently bought by Google, or GeoNames, which allows users to pin Wikipedia articles on the map.

The fourth category differs from the third by the fact that the app has its own content, i.e. it’s not a mashup anymore. MapMyGlobe is in this last category. Everybody can edit the content that’s really the app’s content, not content from a third party. The project that would be most closely related to that, especially on the technical side, would be WikiMapia. However MapMyGlobe differs from WikiMapia by two things: first, while WikiMapia is an attempt at a very generalistic description of the world - which is essentially, placenaming -, MapMyGlobe has a precise purpose: being an virtual travel guide. Second, WikiMapia’s places’ descriptions are static in the sense that some textual content is attached to a particular location. However, MapMyGlobe aims at providing a more interactive way to visit places, thanks to user-defined animations and graphics.

In conclusion, I believe there’s more and more space in today’s internet for collaborative mapping apps, and I hope MapMyGlobe will be a part of this collaborative revolution

The title of this post is a reference to Ward Cunningham’s original description of the wiki as “the simplest online database that could possibly work“. While in theory, you could build an online database by just opening a web interface to your data, this approach just wouldn’t work without basic functionalities such as easy editing - the fact that you can type into a browser form instead of a database field -, open structure - the ability to edit the pages’ organization in addition to the pages’ data -, and most importantly, version control - the fact that all changes or deletions are kept track of and can be reversed in a matter of seconds.

In addition to these basic functions, Collaborative Mapping implies the ability to easily edit graphical stuff: either the map tiles themselves (but that’s a different approach), or, in our case, the map’s overlays. Thus the design problem facing us is to build an application that verifies each of the three properties stated above. In addition to some technical and practical problems - for instance, how do you build an interface to easily edit a polygon? - a few theoretical problems arise as well - for example, what does revision control mean when you’re dealing with sets of points?. The same kind of issues arise with the way frames and pages are organized. The goal is to find an expressive, yet simple solution to these problems. Yesterday I pushed production code’s iteration #2 which corrects a few bugs, and is a step further in that direction. Hope you like it

One of the great things about being a University student is that you get to see remarkable people. Today I got the chance to attend talks by both Brian Behlendorf and Natalie Portman. While both talks were insightful, the speakers kind of have different profiles and backgrounds so I thought it would be interesting to draw parallels and differences between the subjects.

Both speakers actually aim at making the world a better place, albeit in a different way. Behlendorf advocates for open source and collaborative development as a means to empower the masses, and Natalie Portman is an ambassador for a microfinance organization that “promotes micro-lending to help finance women-owned businesses in poor countries“.

I claim there are a couple of parallels between both activities. Microfinance is a form of collaboration if you come to think about it, where lenders and borrowers come together to agree on rules and future development. And open source software - well, at least the one that’s free - enables computer users with little to no resources (e.g., students) to have access to software, the same way microfinance enables poor people to have access to banking services. Moreover, as Brian Behlendorf stated it, collaborative development is hardly limited to software. His company CollabNet built a collaborative system for HP’s electronic circuits. Why not build one for microcredits? Finally, we all know collaborative development implies organizational tools and communication means between developers. Well, microcredit implies easier communications means too, and a great example of that is that a microfinance company recently decided to give a cellular phone to every one of its clients.

Thus, the goal of these non-traditional business practices is to create a virtuous circle, where collaboration sheds more social and economical efficiency, which in turns sheds more collaboration.

Besides these analogies which might sound a bit rhetorical, there’s something that I feel the open source community and the software industry at large could benefit from, and that I’m going to try and articulate. What’s truly innovative about microfinance organizations is that economic and social development is created from below, in the sense that some responsability is given to the very poorest on the planet. This is why the educational value of microcredit is huge. In comparison, current software collaborative development is much less accessible. Barriers to entry to a collaboration project are very high, and the meritocracy behind most organizations can turn into an elitist system, where protagonists really come from the top tiers of academia and corporate research. Since collaborative development is reserved to people that are already literate, there is no real educational value for developers who are either in training, or from parts of the world other than the US. That may explain why outside of the Silicon Valley - as a caricature - most of the web, for example, is 3 or 4 years behind.

That concludes my long post today about a topic that’s undeniably related to collaborative mapping apps such as MapMyGlobe. I’ll end up saying I am grateful to the speakers for inspiring me, both of them - although one of them is somewhat sexier, but I’ll let you decide who …

I just put the application up on the “production server” - really a 10-bucks-a-month shared server - for the first time. I’ve been surprised at how straightforward the deployment has been. While my development machine and the shared host are pretty much the opposite sides of modern computing (different Operating Systems, antinomic configurations, own-machine-flexibility versus shared environment constraints) the whole application was deployed and running in just 10 minutes.

The application has been tested on Firefox 2 and IE7. It works reasonably well on IE6, modulo a few aesthetic flaws in some places. Independently of your browser, there is still a couple of bugs here and there, but those should be resolved fairly soon. I hope you like my application, be sure to play around with it and feel free to contribute!

A massive amount of refactoring is currently going on throughout the MapMyGlobe application’s code. As for any project that’s evolving along the way as it’s being developed, some pieces of code end up replicated, or not in the place they should be. I thought I would write a few words about why I find refactoring hard, but why I do it and why a project sometimes really needs it.

I personally find refactoring intrinsically, and almost metaphysically, difficult. At some point in my projects I know I’m going to have to do some, but then my mind is really tormented and I’m really stressed out, and I’m sure this feeling is shared by a fair number of my fellow programmers. First, we’re afraid that refactoring might break a feature that’s currently working, and that’s indeed often the case, but Version control alleviates this problem (assuming you use it, but I think you should, even when you develop solo) because you can always go back and rectify what’s been broken.

But even with Version control, there’s a feeling, conscious or sub-conscious, of non-reversibility of what we’re doing: in most cases, what has been refactored won’t ever retrieve its past form, so we feel like we’re throwing away some stuff, and this thought really scares us. I don’t want to sound squeamish or anything, but our mind can get really tormented. What happens is that both sides of our mind have something to say: while our rational side pleads for some rewriting and reorganization of our past work to increase future productivity, our creative side is scared, because doing so and looking back at what we’ve done before might stop our creative flow. So in the end, it is the same feeling as an artist who’s in a creative phase and who doesn’t want to stop by fear of losing it. And by the way, what’s a programmer, if not an artist?

One year ago, the Google Maps API development team released a small but pretty neat improvement to their Geocoding API: the ability to get the response’s accuracy level for a given address.

This feature enables applications to modify their zoom level according to the precision of the address that’s being geocoded, for example, “Paris” at the city zoom level, but “1 rue Royale, 75008 Paris” at the much more precise street address zoom level.

What the Google geocoder actually outputs (see reference) is a value between 1 and 8. And the GMaps zoom level is an integer between 1 and 19. So the question is: given a geocoding accuracy, which zoom level should I use to display the place? I didn’t find any answer to that question on the web so I decided to make up my own correspondence between the two scales. Any such correspondence is bound to be imperfect since two different cities can have very different sizes, however the method usually outputs a decent result.

var tabAccuracy = new Array(2,4,6,10,12,13,16,16,17);

function showAddress(address) {
  if (geocoder) {
    geocoder.getLocations(address,
    function(response) {
      if(response.Status.code!=200){
        alert('"' + address + '" not found');
      } else {
        place = response.Placemark[0];
        accuracy = place.AddressDetails.Accuracy;
        map.setCenter(new GLatLng(place.Point.coordinates[1],
             place.Point.coordinates[0]), tabAccuracy[accuracy]);
      }
    }
    );
  }
}

I calibrated the association on a few cities such as Paris, NYC and San Francisco, and I was a bit conservative to ensure that people with small screens still get the picture. Let me know if you find this scale useful.