You are currently browsing the tag archive for the ‘Clouds’ tag.

PoppleAs a diehard lover of old maps, I have been especially excited by Map Dorkia’s recent rediscovery of the charm of bygone cartography.  I came to GIS via history and archaeology, so my generalized love of maps stems from an earlier, more specific love of old maps.  I think this also accounts for the fact that while maps come in many shapes, I am most fond of the ones that depict an actual physical landscape.  So I was thrilled a short while ago when Kartograph arrived on the scene (skillfully showcasing a stunning map of Italy), and I was equally happy when MapBox debuted AJ Ashton’s “Pirate Map”.

While both these maps are quite beautiful and therefore just plain nice to look at, they seem to be laboring under the misconception that beauty was the only strong point of old cartography.  Because of this, they are missing an important point (in my opinion the most important point) of old maps.

This shortcoming was perfectly illuminated by my wife when she entered my office just after I encountered the aforementioned Kartograph map of Italy.

“What’s that?”  she asked.

“A very pretty map,” I answered.

“It is pretty,” my wife agreed.  “But there isn’t very much information on it, is there?”

As usual (although don’t tell her I said so) my wife was exactly correct.  The map sure is pretty, but it conveys very little information (the same can be said of the “Pirate Map”).  As I’ve said before, the whole point of a map is to convey information.  Beauty can certainly serve as part of the means toward this end, but we should be careful to remember that it is not the end in and of itself.

Take a look at this map, created in 1733 by Henry Popple (click on the link or the image to see the whole map at the Rumsey Collection):


As easy to read as it is easy to look at, isn’t it?  Anyone have any trouble figuring out where the forests are?  The mountains?  Delightfully easy to tell the difference between large cities and small towns, isn’t it?  The only issue I can find with this map of any sort is that it’s a bit overcrowded in the label department.  This, however, is simply a shortcoming of the medium, one which we can easily overcome.  More on this in a bit.

Modern maps, on the other hand, tend to be much less easy to read.  Often, features like forests are depicted with colored blobs, the explanation of which are necessarily supplied in a legend of some sort (clearly, if we’re lucky.  If we’re not lucky, we may be wasting our time trying to differentiate between the green blobs that are forests and the blobs of a slightly different shade of green which are parks).  While techniques such as this do (technically) suffice, they are rather inelegant.  I have long felt (and often remarked) that every entry in a legend represents a failure on the part of the cartographer.

The ideal solution lies in a mixture of modern data and tools coupled with classical cartographic techniques.  Why represent a forest as a green blob instead of populating it with trees?  The capability certainly exists – it’s easy enough to convert a forest polygon into a teeming mass of randomly placed points.  Points which can then be represented graphically as trees.

But then we run into the problem of numbers.  A forest measuring in acres (or even square miles) can take a lot of points to fill.  This means a boat-load of tiny little pictures of trees that need to be drawn.  The problem isn’t so bad if we’re just producing a static map – then it’s just my machine that has to do all the work, and it only has to do it once.  But what if we want to serve this up as a web map?  Then we’re talking about rendering insane numbers of little trees at both ends of the exchange.  A ridiculous expenditure of resources under the best of circumstances.

Until TileMill came along, that is.  I’ve talked about TileMill before, and it’s long past time I revisited the subject.  When last we discussed it, TileMill only ran in Apple and Linux machines, and it was no small task to get it up and running (and it tended to be a little buggy at that).  Now it’s a simple matter of searching the Ubuntu repositories (for Linux) or just downloading an installer (for Windows).  I assume it’s equally as simple to set up TileMill for OS X.  And today the bugs are few and far between (and tend to be squashed with great alacrity and enthusiasm).

Using TileMill, we can take current data and old cartographic techniques and join them into an accurate, attractive and (above all) easy to read basemap:


Do click on the map and check out the fully functional version.  Please be aware that I created this map simply as a proof of concept, so there are a few limitations:  1) The map is running on a crappy little server on the floor in my office, and it’s being hosted on a stupid little web page my ISP provides free of charge.  So please don’t hit it too hard [Update:  After posting this last night, I was contacted by Eric from MapBox (thanks, Bill).  Eric offered me a sweet deal for MapBox hosting, and by sweet I’m referring to another word with a double ‘ee’ (no – not ‘beer’).  While I believe in the abilities of my little server, I am also not stupid.  So I happily took Eric up on his offer.  The upshot of this is that the map is now being served by MapBox and therefore you should all feel free to kick the crap out of it].  2) Even though I largely confined the map to geographic features, we’re still talking enormous amounts of data here.  Because of this, I restricted the map to 7 levels of zoom and a geographic area that represents roughly the central third of Massachusetts.  And we’re still talking an MBTiles file that takes up well over a gigabyte.  3) I am certain there are numerous errors on the map.  If I had been making this map for a client rather than as an experiment I would have spent more time seeking them out and removing them.  4) I did not (nor do I now) give a crap about the page surrounding the map.  I simply slapped together a fast and dirty container for the map itself, literally in less time than it has taken me to write this sentence.  If you have any criticisms regarding it, know that I am completely and blissfully indifferent toward them.

While I am less than completely pleased with the end result, I am quite happy with what the result represents.  I don’t feel the techniques I employed are terribly far removed from those employed by Popple and his contemporaries (although I did freely use some colors, I could have achieved much the same effect in greyscale), and in the cases where I diverged I’m sure they would have approved (since I have the luxury of scale and zoom control, my ability to comprehensively label a map without overcrowding it would probably make Popple green with envy).  Mostly, I’m pleased by the fact that the map is almost completely self-explanatory.  In fact, the only explanations of any kind on the map are the labels, all of which are simply placenames.

All things considered, I think I’ll put this project in the ‘win’ column.

Notes:  There are a few changes I would make to the map if I were producing it “for real”.  Besides the aforementioned data cleansing, the most important of these would be the labels.  For this project, I baked the labels directly into the tiles, simply because I felt the map needed some sort of labels.  Ideally, though, the basemap wouldn’t contain any labels at all.  Instead, I would apply all labels over the basemap, well after the fact (I’ve heard that CartoDB plans to eventually allow home-brewed MBTiles to serve as basemaps on their platform.  I can’t think of a better scenario for serving up my nefarious schemes).  And I would most certainly include more labels than are currently present on the map (streets, for example).

The “trees” on the map are placed randomly within the confines of forest polygons.  If the polygon data differentiated between deciduous, coniferous and mixed stands, it would be a simple matter for the graphics to represent them accurately.

Nuts And Bolts:  The data I used for this map came mostly from MassGIS.  I also availed myself of some data from USGS and OpenStreetMap.  The data was tweaked and altered and arranged and (in some cases) soundly beaten using Quantum GIS and ArcGIS Desktop.  Graphics were produced and/or altered using Photoshop and Inkscape.  The font used for the labels is called Essays 1743TileMill was (of course) used to bake the tiles.  TileStream is serving the tiles from my hapless little server (it was a bit of a bear to get TileStream up and running.  These instructions by Nathaniel Kelso finally got me where I needed to be).  If I were going to serve up maps like this “for real”, I would avail myself of MapBox hosting rather than using my own server. [Update 2:  I unforgivably forgot to mention Leaflet, which played a major role in the speed with which I was able to deploy my map on a web page.  Since switching the map over to MapBox hosting, Wax has also played a part in the process.]


CloudNote: This is the fourth and last part in a series on building your own home-brewed map server  It is advisable to read the previous installments, found here, here and here.

This is the point at which the tutorial-like flavor of this series breaks down, for a variety of reasons.  From here on, we’ll be dealing with divergent variables that cannot be easily addressed.  We’ll discuss them each as they come up.  Suffice to say that from now on I can only detail the steps I have taken.  Any steps you take will depend on your equipment and circumstances.

Having finished putting my server together, I decided it was time to give it a face to show the world.  Before I could do so, however, I had to give it a more substantial connection to that world, a process that began with establishing a dedicated address (domain).  The most common method of achieving this is to simply purchase one (i.e.,  There are a variety of web hosts you can turn to for this.  I cannot personally recommend any of them (due only to personal ignorance).

For the purpose of this exercise I didn’t feel I needed a whole lot (all I really wanted was an address, since I intended to host everything myself), so I went to DynDNS and created a free account (thanks, Don).  DynDNS set me up with a personal address, and the use of their updater makes it work for dynamic addresses (which most routers provide).  The web site does a decent job of walking you through the process, including setting up port forwarding in your router.

Exactly how to go about forwarding a port is particular to the router in question, so I won’t go into it in detail.  I will say that it is not something that should be approached lightly.  Port forwarding can pose certain security risks.  It’s a very good idea to do some research into the process before you dabble in it.

Once I had an address and a port through which to use it, I had to choose a front end for my server.  I was tempted to go with Drupal, mainly because it has the best documented means with which to serve up TileStream, but also because I’ve been meaning to learn my way around Drupal for some time now.

In the end, I realized that my little server, despite being almost Thomas-like in its dedication and willingness to serve, just doesn’t have the cojones necessary for serving those kind of tiles.  Truth is, if I wanted my own custom base map tiles in an enterprise environment, I’d purchase MapBox’s TileStream hosting rather that serving it myself, anyway. (Umm… I really couldn’t have been more wrong about this.)

And so I decided learning Drupal could wait for another day.  Instead I chose to go with WordPress, for several reasons.  I’m reasonably familiar with it, it’s a solid, well-constructed application, it’s extremely customizable, and it has an enormous, dedicated user base who have written huge amounts of themes and plugins.  And while WordPress was originally intended to be a blogging platform (and remains one of the best), it’s easy enough to reconfigure it for other purposes.

Installing WordPress is a snap since we included LAMP (Linux Apache, MySQL and PHP) while initially installing Ubuntu Server Edition.  In the terminal, type:

sudo apt-get install wordpress

Let it do its thing.  When it asks if you want to continue, hit ‘y’.  When it gets back to the prompt, type:

sudo ln -s /usr/share/wordpress /var/www/wordpress

sudo bash /usr/share/doc/wordpress/examples/setup-mysql -n wordpress

But replace ‘’ with the address you created at DynDNS.

Back to Webmin.  On the sidebar menu, click on Servers→Apache Webserver→Virtual Server.  Scroll down to the bottom.  Leave the Address at ‘Any’.  Specify the port you configured your router to forward (should be port 80, the default for HTTP).  Set the Document Root by browsing to  /var/www/wordpress.  Specify the Server Name as the address you created at DynDNS (the full address – include http://).  Stop and start Apache for good measure.

Now you should be able to point your browser to your DynDNS-created address (hereafter referred to as your address) to complete your configuration of WordPress.  You will have to make many decisions.  Choose wisely.

Once you have WordPress tweaked to your satisfaction, you’re probably going to want to add some web map functionality to it.  First and easiest is Flex Viewer.  All you have to do is move the ‘flexviewer’ folder from /var/www to  /usr/share/wordpress.  The file manager in Webmin can do this easily.  Once you’re done, placing a Flex Viewer map on a page looks something like this:

<iframe style="border: none;" height="400" width="600" src="http://your address/flexviewer/index.html"></iframe>

Straightforward HTML.  Nothing fancy, once all the machinery is in place.

Which gets a little trickier for GeoServer.  By design, GeoServer only runs locally (localhost).  In order to send GeoServer maps out to the universe at large, we have to do so through a proxy.  This has to be configured in Apache.  Luckily, Webmin makes it a relatively painless process.

We’ll start by enabling the proxy module in Apache.  Click on Servers→Apache Webserver→Global Configuration→Configure Apache Modules.  Click the checkboxes next to ‘proxy’ and ‘proxy_http’, then click on the ‘Enable Selected Modules’ button at the bottom.  When you return to the Apache start page, click on ‘Apply Changes’ in the top right-hand corner.

Having done that, we can point everything in the right direction.  Go to Servers→Apache Webserver→Virtual Server→Aliases and Redirects.  Scroll to the bottom and fill in the boxes thus:


Your server will have a name other than maps.  Most likely, it will be localhost.  In any case, you can find it by looking in the location bar when you access the OpenGeo Suite.  Apply the changes again, and you might as well stop Apache and restart it for good measure.

You can now configure and publish maps through GeoExplorer.  The only caveat is that GeoExplorer will give you code that needs a minor change.  It will use a local address (i.e., localhost:8080) that needs to be updated.  Example:

<iframe style="border: none;" height="400" width="600" src="http://localhost:8080/geoexplorer/viewer#maps/1"></iframe>

changes to

<iframe style="border: none;" height="400" width="600" src="http://your address/geoexplorer/viewer#maps/1"></iframe>

And that – as they say – is that.  Much of this has entailed individual choices and therefore leaves a lot of room for variation, but I think we’ve covered enough ground to get you up and running.  If you want to see my end result, you can find it at:

The Monster Fun Home Map Server Webby Thing

I won’t make any promises as to how long I will keep it up and running, but it will be there for a short while, at least.  Keep in mind that it is a work in progress.  So be nice.

Update:  My apologies to anyone who may give a crap. but I have pulled the plug on the Webby Thing.  It was really just a showpiece, and I just couldn’t seem to find the time to maintain it properly.  And frankly, I have better uses for the server.  Sorry.

CloudNote: This is the third part in a series on building your own home-brewed map server  It is advisable to read the previous installments, found here and here.

Last time, I walked you through installing TileMill, and I promised a similar treatment for TileStream and Flex Viewer.  I am a man of my word, so here we go.  Don’t worry – this will be easy in comparison to what we’ve already accomplished.

We’ll start with TileStream, simply because we’re going to have to avail ourselves of the command line.  Once again, you can either plug a keyboard and monitor into your server or use whatever SSH client you’ve been using thus far.

Once you’re in the terminal, take control again (‘sudo su’).  For your TileStream installation, you can follow the installation instructions as presented, except for one detail:  it’s assumed we already have an application we don’t have.  Let’s correct that:

sudo apt-get install git

And then proceed with the installation (don’t forget to hit ‘enter’ after each command):

sudo apt-get install curl build-essential libssl-dev libsqlite3-0 libsqlite3-dev

git clone –b master-ndistro git://

cd tilestream


And that’s that (TileStream, even more than TileMill, will throw up errors during the installation.  None of them should stop the process, though, so you can safely ignore them).  Like TileMill, TileStream needs to be started before it can be accessed in a browser.  Since the plan is to run the server headless, let’s set this up in Webmin in a fashion similar the one employed for TileMill.

Back to Webmin, again open the ‘Other’ menu, and this time click on ‘Custom Commands’.  We’ll create a new Custom Command and configure it as follows (substitute your name for mine as appropriate):

TileStream Command

Save it, and you will now have a Custom Command button to use for starting TileStream (we didn’t do this for TileMill because we cannot.  The Webmin Custom Command function simply won’t accept it.  I think it has to do with the nature of the command.  I think the ‘./’ in the TileMill command confuses it).

At this point, TileStream is fully functional, but it doesn’t yet have a tileset to work with.  Using the same browser with which you just accessed Webmin, go here to download one.  Scroll down the page, pick a tileset you like and click on it to proceed to the download page (I picked World Light).  Download the file to wherever you please.  Once you have the file, go back to Webmin and open the ‘Other’ menu again.  Click on ‘Upload and Download’, then select the ‘Upload to Server’ tab.  Click on one of the buttons labeled ‘Choose File’, then browse to the tileset file you downloaded.  For ‘File or directory to upload to’, click the button and browse your way to /home/terry/tilestream/tiles (by now, you should know you’re not ‘terry’).  Click the ‘Upload’  button.

Once your tileset is finished uploading, you can point the browser to http://maps:8888 (yeah, yeah – not ‘maps’) to access TileStream.  Enjoy:


Our last order of business is Flex Viewer (otherwise known as ‘ArcGIS Viewer for Flex’).  This is the easiest of the lot, mainly because it doesn’t actually have to be installed.  Still using the same browser, go to the download page (you’ll need an ESRI Global Account.  If you don’t have one, create one), agree to the terms and download the current version (again – download it to wherever you please).  Once you have the package, use Webmin to upload it to the server.  This time you’ll want to upload the file to /var/www and you’ll want to check the ‘Yes’ button adjacent to ‘Extract archive or compressed files?’

And you’re in.  Point the browser to http://maps/flexviewer/ (you know the drill) and play with your new toy:


You can see I have customized the flex viewer.  You should do so as well (it’s designed for it, after all).  Open the file manager in Webmin (the ‘Other’ menu again) and navigate to /var/www/flexviwer.  Select config.xml, then click the ‘Edit’ button on the toolbar.  The rest is up to you.

* * * * *

So now you have a headless Ubuntu map server up and running, and the question you are probably asking yourself is:  “Do I really need all this stuff running in my server?”  The answer is, of course, ‘no’.  The point of this exercise was to learn a thing or two.  If you’ve actually been following along and have these applications running in your own machine, you are now in a good position to poke around for a while to figure out what sort of server you’d like to run.

For instance, there’s no real reason to run TileMill on a server.  TileMill doesn’t serve tiles, it fires them.  Therefore it’s probably not the best idea to be eating up your server’s resources with TileMill (and it seriously devours resources).  The server doesn’t have a use for the tiles until they’re done being fired, at which point TileStream is the tool for the job.

That said, there’s no compelling reason why you couldn’t run TileMill on your server.  If you’d rather not commit another machine to the task (and if you’re not in any kind of hurry), why not give the job to the server?  It’ll take it a while, but it will get the tiles fired (if your server is an older machine like mine, I would strongly advise you to fire your tiles in sections, then put them together later.  I suggest firing them one zoom level at a time and combining them with SQLite Compare).

Flex Viewer and the OpenGeo Suite don’t often go together, but there’s no reason why they can’t.  Flex Viewer can serve up layers delivered via WMS – there’s nothing to say GeoServer can’t provide that service.  They are, however, very different applications, with vastly different capabilities, strengths and weaknesses.  They also have a very different ‘feel’, and we should never discount the importance of aesthetics in the decision making process.

A final – and very important – consideration in the final configuration of our home server is the nature of the face it presents to the world.  In order for a server to serve, it must connect to and communicate with the world at large.  This means some kind of front end, the nature of which will influence at least some of our choices.

Which brings us neatly to the next post.  See you there.

CloudNote:  This is the second part in a series on building your own home-brewed map server (I would tell you how many installments the series will entail, but I won’t pretend to have really thought this through.  There will be at least one more.  Probably two).  It assumes you have read the previous installment.  You have been warned.

Last time, I walked you through setting up your very own headless map server using only Free and Open Source Software.  Now, I’m going to show you how to trick it out with a few extra web mapping goodies.  The installation process will be easiest if you re-attach a ‘head’ to your server (i.e., a monitor and keyboard), so go ahead and do that before we begin (alternately, if you’re using PuTTY to access your headless server, you can use it for this purpose).

At the end of my last post, I showed you all a screenshot of my server running TileMill, TileStream and Flex Viewer, and I made a semi-promise to write something up about it.  So here we are.

I tend toward a masochistic approach to most undertakings in my life, and this one will not deviate from that course.  Whenever I am faced with a series of tasks that need completion, I rank them in decreasing order of difficulty and unpleasantness, and I attack them in that order.  In other words, I work from the most demanding to the least troublesome.

I originally intended to write a single post covering TileMill, TileStream and Flex Viewer, but a short way into this post I realized that I had to split it into two pieces.  The next post will cover TileStream and Flex Viewer.  This one will get you through TileMill.

TileMill can be a bear to install – not because you need catlike reflexes or forbidden knowledge or crazy computer skills – but simply because there are many steps, which translate into lots of room for error.  A quick glance at TileMill’s installation instructions may seem a bit daunting (especially if you’re new to this kind of thing):

Install build requirements:

# Mapnik dependencies 
sudo apt-get install -y g++ cpp \ 
libboost-filesystem1.42-dev \ 
libboost-iostreams1.42-dev libboost-program-options1.42-dev \ 
libboost-python1.42-dev libboost-regex1.42-dev \ 
libboost-system1.42-dev libboost-thread1.42-dev \ 
python-dev libxml2 libxml2-dev \ 
libfreetype6 libfreetype6-dev \ 
libjpeg62 libjpeg62-dev \ 
libltdl7 libltdl-dev \ 
libpng12-0 libpng12-dev \ 
libgeotiff-dev libtiff4 libtiff4-dev libtiffxx0c2 \ 
libcairo2 libcairo2-dev python-cairo python-cairo-dev \ 
libcairomm-1.0-1 libcairomm-1.0-dev \ 
ttf-unifont ttf-dejavu ttf-dejavu-core ttf-dejavu-extra \ 
subversion build-essential python-nose 

# Mapnik plugin dependencies 
sudo apt-get install libgdal1-dev python-gdal libgdal1-dev gdal-bin \ 
postgresql-8.4 postgresql-server-dev-8.4 postgresql-contrib-8.4 postgresql-8.4-postgis \ 
libsqlite3-0 libsqlite3-dev  

# TileMill dependencies 
sudo apt-get install libzip1 libzip-dev curl 

Install mapnik from source:

svn checkout -r 2638 mapnik 
cd mapnik python scons/ configure INPUT_PLUGINS=shape,ogr,gdal 
python scons/ 
sudo python scons/ install 
sudo ldconfig 

Download and unpack TileMill. Build & install:

cd tilemill ./ndistro 

It’s not as scary as it looks (the color-coding is my doing, to make it easy to differentiate things).  The only circumstance that makes this particular process difficult is that the author of these instructions assumes we know a thing or two about Linux and the command line.

Let’s start at the top, with the first ‘paragraph’, which begins: # Mapnik dependencies.  Translation:  We will now proceed to install all the little tools, utilities, accessories and such-rot that Mapnik (a necessary and desirable program) needs to function (i.e., “dependencies”).

It is assumed that we know the entire ‘paragraph’ is one command and that the forward-slashes (/) are not actually carriage returns and shouldn’t be followed by spaces.  It is also assumed that we will notice any errors that may occur during this process, know whether we need concern ourselves with them and (if so) be capable of correcting them.

Let’s see what we can do about this, shall we?  Since we’re installing this on our server and actually typing in the commands (rather than copying and pasting the whole thing), we have the luxury of slicing it up into bite-sized pieces.  This way the process becomes much less daunting, and it makes it easier for us to correct any errors that crop up along the way.

We’ll start by taking control.  Type “sudo su” (sans quotation marks), then provide your password.  Now we can proceed to install everything, choosing commands of a size we’re comfortable with.  I found that doing it one line at a time works pretty smoothly.  Two important points here:  start every command with “sudo apt-get install” (not just the first line) and don’t include the forward-slashes (unless you’re installing more than one line at a time).  I would therefore type in the first two lines like this (don’t forget to hit ‘enter’ at the end of each command):

sudo apt-get install –y g++ cpp

sudo apt-get install libboost-filesystem1.42-dev

You get the idea.  Continue along in this fashion until you have installed all the necessary dependencies for Mapnik.  I strongly recommend doing them all in one sitting.  It just makes it easier to keep track of what has and hasn’t been installed.

At this stage of the game, any errors you encounter will most likely be spelling errors.  Your computer will let you know when you mistype, usually through the expedient of informing you that it couldn’t find the package you requested.  When this occurs, just double-check your spelling (hitting the ‘up’ cursor key at the command prompt will cause the computer to repeat your last command.  You can then use the cursors to correct the error).  At certain points in the installation process, your server will inform you of disk space consumption and ask you to confirm an install (in the form of yes/no).  Hitting ‘y’ will keep the process moving along.

While packages install in your system, slews of code will fly by on your screen, far too fast to read or comprehend.  Just watch it go by and feel your Geek Cred grow.

By now you should have developed enough Dorkish confidence to have a go at # Mapnik plugin dependencies and # TileMill dependencies.  Have at it.

When you’re done, move on to installing Mapnik from source.  Each line of this section is an individual command that should be followed by ‘enter’.  The first line will throw up your first real error.  Simply paying attention to your server and following the instructions it provides will fix the problem (in case you missed it, the error occurred because you haven’t installed Subversion, an application you attempted to use by typing the command ‘svn’.  Easily fixed by typing sudo apt-get install subversion).  You can then re-type the first line and proceed onward with the installation.  When you get to the scons commands, you will learn a thing or two about patience.  Wait it out.  It will finish eventually.

Now we should be ready to do what we came here to do:  install TileMill.  Unfortunately, TileMill’s installation instructions aren’t very helpful at this point for a headless installation.  All they tell us is to “Download and unpack TileMill”.  There’s a button further up TileMill’s installation page for the purpose of the ‘download’ part of this, but it’s not very helpful for our situation.  We could use Webmin to manage this, but what the hell – let your Geek Flag fly (later on, we’ll use Webmin to install Flex Viewer, so you’ll get a chance to see the process anyway).

Our installation of Mapnik left us within the Mapnik directory, so let’s start by returning to the home directory:


Then we can download TileMill:

wget –no-check-certificate

Now let’s check to confirm the name of the file we need to unpack:


This command will return a list of everything in your current directory (in this case, the home directory).  Amongst the files and folders listed, you should see ‘0.1.4’ (probably first).  Let’s unpack it:

unzip 0.1.4

Now we have a workable TileMill folder we can use for installation, but the folder has an unwieldy name (which, inexplicably, the installation instructions fail to address).  Check your directory again to find the name of the file you just unpacked (in my case, the folder was ‘mapbox-tilemill-4ba9aea’).  Let’s change that to something more reasonable:

mv mapbox-tilemill-4ba9aea tilemill

At long last, we can follow the last of the instructions and finish the installation:

cd tilemill


Watch the code flash by.  Enjoy the show.  This package is still in beta, so it will probably throw up some errors during installation.  None of them should be severe enough to interrupt the process, though.  Feel free to ignore them.

Once the installation is complete, we’ll have to start TileMill before we can use it.  This can be achieved by typing ‘./tilemill.js’in the terminal, but TileMill actually runs in a browser (and we’ll eventually need to be able to run it in a server with no head), so let’s simplify our lives and start it through Webmin.

Go to the other computer on your network through which you usually access your server (or just stay where you are, if you’ve been doing all this through PuTTY), open the browser and start Webmin.  Open the ‘Others’ page and select ‘Command Shell’.  In the box to the right of the ‘Execute Command’ button, type:

cd /home/terry/tilemill (substitute your own username for ‘terry’)

Click the ‘Execute Command’ button, then type in:


Click the button again (after you’ve gone through this process a couple of times, Webmin will remember these commands and you’ll be able to select them from a drop-down list of previous commands).

And now enjoy the fruits:  type http://maps:8889 into the location bar of your browser (again, substitute the name of your server for ‘maps’).  Gaze in awe and wonder at what you have wrought:


Take a short break and play around with the program a bit.  You’ve earned it.  When you’re done I’ll be waiting at the beginning of the next post.

CloudFellow Map Dork and good Twitter friend Don Meltz has been writing a series of blog posts about his trials and tribulations while setting up a homebrewed map server on an old Dell Inspiron (here and here).  I strongly recommend giving them a read.

At the outset, Don ran his GeoSandbox on Windows XP, but recently he switched over to Ubuntu.  While I applaud this decision whole-heartedly, I thought I’d take the extra step and build my own map server on a headless Ubuntu Server box (when I say ‘headless’, I am talking about an eventual goal.  To set this all up, the computer in question will initially need to have a monitor and keyboard plugged into it, as well as an internet connection.  When the dust settles, all that need remain is the internet connection).  The following is a quick walkthrough of the process.  I apologize to any non-Map Dorks who may be reading this.

The process begins, of course, with the installation of Ubuntu 10.04 Server Edition.  Download it, burn it to a disk, and install it on the machine you have chosen to be your server.  Read the screens that come up during installation and make the decisions that are appropriate for your life.  The only one of these I feel compelled to comment on is the software selection:


The above image shows my choices (what the hell – install everything, right?).  Definitely install Samba shares.  It allows Linux machines to talk to others.  Also, be sure to install the OpenSSH server.  You’ll need it.  For our purposes, there’s no real reason to install a print server, and installing a mail server will cause the computer to ask you a slew of configuration questions you’re probably not prepared to answer.  Give it a pass.

During the installation process, you will be asked to give your server a name.  I named mine ‘maps’.  So whenever I write ‘maps’, substitute the name you give your own machine.

Once your installation is complete, you will be asked to login to your new server (using the username and password you provided during installation), after which you will be presented with a blinking white underscore (_) on a black screen.  This is a command prompt, and you need not fear it.  I’ll walk you through the process of using it to give yourself a better interface with which to communicate with your server.  Hang tight.

Let’s begin the process by taking control of the machine.  Type in “sudo su” (sans quotation marks) and hit ‘enter’.  The server will ask for your password, and after you supply it, you will be able to do pretty much anything you want.  You are now what is sometimes called a superuser, or root.  What it means is that you are now speaking to your computer in terms it cannot ignore.  This circumstance should be treated with respect.  At this stage, your server will erase itself if you tell it to (and it won’t ask you whether or not you’re sure about it – it’ll just go ahead and obey your orders).  So double-check your typing before you hit ‘enter’.

Now, let’s get ourselves a GUI (Graphical User Interface).  The server edition we’re using doesn’t have its own GUI, and for good reasons (both resource conservation and security).  Instead, we can install Webmin, a software package that allows us to connect to our server using a web browser on another computer on the same network.  We’ll do this using the command line.  Type in (ignore the bullets before each command.  They are only there to let you know where each new line begins):

And hit ‘enter’ (I’m not going to keep repeating this.  Just assume that hitting ‘enter’ is something you should do after entering commands{the dark words}).  Follow this with:

  • sudo dpkg -i webmin-current.deb

And finish it up with:

  • sudo apt-get -f install

Now we have a GUI in place.  If you open a browser on another computer on your network and type: https://maps:10000 into the location bar (remember to replace ‘maps’ with the name you gave your own server), you’ll be asked to supply your username and password, then you’ll see this (you may also be asked to verify Webmin’s certificate, depending on your browser):

Cool, huh?  Don’t get your hopes up, though.  We’re not done with the command line yet (don’t sweat it – I’ll hold your hand along the way.  Besides – you should learn to be comfortable with the command line).  For the moment, though, let’s take a look around the Webmin interface.  There is a lot this program can do, and if you can find the time and determination it would be a good idea to learn your way through it.  For now, you just really need to know a few options.  The first is that the initial page will notify you if any of your packages (Linux for ‘software’) have available updates.  It’s a good idea to take care of them.  If you want, Webmin can be told to do this automatically (on the update page you get to when you click through).  The other important features are both located under the ‘Other’ menu (on the left).  The first is the file manager (which bears a striking resemblance to the Windows File Manager of old), which gives you the ability to explore and modify the file system on your server (this feature runs on Java, so be sure the browser you’re using can handle it).  The other feature is ‘Upload and Download’ which does what it says it does.  Together, these two features give you the ability to put maps on your map server, something I assume you’ll want to do.

Please note the specs on my server (as pictured above).  It’s not terribly different than Don’s Inspiron.  I’m not suggesting you do the same, but it is worth noting that an old machine can handle this job.

Back to the command line.  Let’s get OpenGeo:

Rock and roll.  When your server is done doing what it needs to do, go back to the browser you used for Webmin and type http://maps:8080/dashboard/ into the location bar.  Check out the OpenGeo goodness.

Finally, to make your new server truly headless, you’re going to need some way to login remotely (when you turn the machine on, it won’t do a damn thing until you give it a username and password).  Since you listened to me earlier and installed the OpenSSH server, you’ll be able to do this.  All you need is an SSH client.  If you’re remotely connecting through a Linux machine, chances are you already have one.  In the terminal, just type:

  • ssh <username>@<computer name or IP address>

In my case, this would be:

  • ssh terry@maps

You’ll be asked for a password, and then you’re in (I hear this works the same in OS X, but I cannot confirm it).

If you’re using a Windows machine – or if you just prefer a GUI – you can use PuTTY.  PuTTY is very simple to use (and it comes as an executable.  I love programs that don’t mess with the registry).  Tell it the name of the computer you want to connect to and it opens a console window asking for your username and password.  Tell it what it wants to know.

It’s not a bad idea to install a new, dedicated browser for use with your new server.  I used Safari, but only because I already use Firefox and Chrome for other purposes.  Also, your network will probably give your server a dynamic IP address.  This is not an issue for you, since your network can identify the machine by name.  If you want to (and there are several valid reasons to do so), you can assign a static IP address to your server.  To find out how to do so, just search around a bit at the extraordinary Ubuntu ForumsUpdate:  It seem that Webmin provides an easy method to assign a static IP address to your server.  Go to Networking → Network Configuration → Network Interfaces → Activated at Boot.  Click on the name of your active connection, and you will then be able to assign a static IP address just by filling in boxes.

Enjoy your map server.  If I can find the time, I’ll write up a post on how I added Flex Viewer, TileMill and TileStream to the server:

And 50 bonus points to anyone who understands the image at the top of this post.

Windows Live The other night my wife and I watched the last episode of Glee (great fun.  I highly recommend the show).  The program takes place in a high school and, as such, much of the storyline revolves around the social aspects of that purgatory of the teen years.  Halfway through the program, I realized something about my own high school experience:

I have no idea who the popular kids were.  Additionally, I have no idea who the unpopular kids were.  In a nutshell, I have no recollection of the social life in my high school of any kind.

I have my closest friends to thank for this.  We all met while attending (or rather, while we were supposed to be attending) high school, and one of the things that first brought us all together was a shared disdain for pretty much anything society had to offer.  Even at 16 years of age, we had realized that the status quo was not ‘quo’ (as Dr. Horrible so succinctly put it) and our collective response to it was to pretty much opt out.  I really miss my teenage omniscience.

I bring all this up because my lack of experience with the high school social scene has left me ill-equipped to deal with vast portions of the internet.  In case you haven’t noticed , much of the so-called ‘Social Web’ is simply a substitute for the popularity contest that was high school.  With one important difference:  The popular kids on the internet are usually the ones who were unpopular in high school.  And they’re generally pretty angry about it.

Sometimes the popularity contest simply manifests itself as comparing numbers of ‘friends’ (a quaint euphemism for people you’ve never met).  This is the kind of score-keeping you see at Facebook and Twitter.   For the most part, it’s pretty harmless (especially at Twitter, where no one ever seems to care how many ‘friends’ you have.  One of the reasons Twitter is the only corner of the ‘Social Web’ I regularly visit), pretty much just amounting to a method of keeping score.

Other times, though, the popularity contest results in gang-like behavior.  This usually manifests in the comment sections of popular web sites, particularly those that are self-moderating.  While crowd-sourcing can be a very good thing (see OpenStreetMap and/or Wikipedia), any time you put power into the hands of the mob, you run the risk that it will behave like – well – a mob (see Lord of the Flies).  There is a very popular tech website that is a perfect example of this.  I will refrain from mentioning it by name (suffice to say it can be referred to using only punctuation).  This site used to be the source for most kinds of technical information, so when I was writing a post about Google Wave I paid the site a visit to see what the geeks were saying about it.

I was greatly disappointed to discover that the site has been largely taken over by juvenile idiots.  Sadly, I left having learned nothing of value about Wave. (I have since learned that disagreeing with the ‘wisdom’ of the mob at this site gets you quickly relegated to the status of ‘Troll’.  I proudly admit that I am currently considered a ‘Troll’, and I stop by every now and again to disagree with someone, thereby maintaining my ‘Trolldom’.  I know – my own little bit of juvenile behavior.)

Some sites avoid this.  One such is Lifehacker, a site I’ve been visiting for years.  I’ve found it to be a good source of ideas and advice (you know – life ‘hacks’), but they also regularly point their readers to good sources of (usually free or cheap) software.

Which is what all this has been leading up to.  The other day Lifehacker had a post about Windows Live Writer, which is part of the whole Windows Live suite.  Based on that post, I decided to download Live Writer and give it a whirl, which I am doing at this very moment.  And I have to say I’m quite pleased.  I’ve always been a fan of WYSIWYG editors, and Live Writer really delivers on that score.  It feels very much like writing directly to my blog.  I could get used to this. Not that there’s anything particularly wrong with WordPress’s built-in editor.  Live Writer has a better interface, though, and just plain looks better.

And I was very pleased to see the fashion in which Live Writer was packaged.  The installer offers a suite of applications, most of which Windows users will be familiar with.  Apps like Messenger and Mail (neither of which I use, both of which I was happy to see as no longer being included in a standard Windows install).  I was especially happy to see Windows Movie Maker, the unsung hero of Microsoft products.  While it doesn’t pack a whole lot of punch (as video editing software goes), its lack of cost and ease of use make it one of the home movie enthusiast’s best friends.

I have to admit, though, that I would be using Live Writer even if it didn’t have a pleasing interface and was difficult to use.  Why?  Because it lets me easily do this:

Map picture

Makes me a happy Map Dork indeed.

Update:  Looks like I can do this with Google Maps, too:

Unfortunately, though, not with OpenStreetMap.


I first came across Wordle a while ago.  It’s a fun, word collage-creating website.  You give it a URL, or just a collection of text, and it produces a collage for you.  The words in the collage are weighted, ostensibly based upon the frequency with which they’re used (much like a tag cloud, I suppose).

Anyway, I stopped by Wordle today, and punched in this URL.  Here’s the collage that resulted:

WordleI am oddly and inexplicably proud of this Wordle.  Go figure.


Blog Stats

  • 24,016 hits


February 2017
« Jul