Waterunderground is an interactive visualization of global ground-water fluctuations on a monthly basis from 2002 to present.

It was built with the infamous Three.js.

Navigation is located in the footer.

The data used is from NASA’s Gravity Recovery and Climate Experiment (GRACE), freely available here and courtesy of the UC Center for Hydrologic Modeling.

Flood Map 3D Simulation

A web-based flood simulation is developed for navigating over the flood inundation map of Cedar Rapids, Iowa. More here.

Flood Game

A flood game in HTML5 (Youtube)

More videos from Ibrahim Demir of the Iowa Flood Center

OpenScalesGL

OpenScalesGL is the HTML5/WebGL version of the ActionScript-based “rich mapping” framework. The video below is a preview of what’s coming in summer 2012.

Another video, Desktop Firefox (Youtube).

ReadyMap Web SDK

ReadyMap is a free Javascript library for 3D/2D web mapping. It works with TMS/WMS and WebGL. (Github repo).

If your video card and webbrowser are recent enough, check out the demos. Especially this one which renders layers from an ESRI ArcGIS Server.

Nokia Maps 3D WebGL Beta

100% 3D maps, 0% plug-in, currently in beta.

Tip: Try zooming in a bit to Cape Town or New York and click on the label. It beautifully zooms in and goes into more detail. Very nice.

USGS Texture Blending demo

A visualization of the USGS elevation data using Three.js/WebGL. Technical background information here. More WebGL from Chandler Prall.

WebGL Nature Scene

A WebGL nature scene based upon NVIDIA’s Nature demo project.

Live demo.

This is an effort to integrate some interesting shader based rendering techniques to present realistic-looking nature scene on web using Javascript and WebGL (SpiderGL to be precise). The techniques applied in this demo include:

• Multi-layered Terrain
• Waving Grass with Countless Blades
• Realistic Water Simulation with Reflection and Refraction
• Dynamic Cloudy Sky Dome
• Flying Birds with Flocking Behaviour

Earthquake Visualization

Nine Point Five is a WebGL visualization exploring earthquakes over the past 30 years. (More information) Built by Dean McNamee who also seems to do nice physical world experiments.

World Flights

World Flights is a WebGL visualization of major airline flights, built using Sencha’s PhiloGL Framework by Nicolas Garcia Belmonte.

Miscellaneous Links

• GPU-accelerated heightmap generation in WebGL

• libnoise.js

• Streaming Level of Detail Terrain using SpiderGL

• OpenWebGlobe beta from the University of Applied Sciences Northwestern Switzerland.

• SceneJS, a JSON-based scene graph API on WebGL. 2.0 release

Tabata Pro is a timer application for use with the Tabata training protocol also known as High Intensity Interval Training. I’ve only used it for a training or ten, but I can say it works perfectly. It’s definitely as good as the famous Gym Boss timers.

Wild Chords

Wild Chords is a free guitar learning app. I actually can’t believe it’s free, because it’s brilliant. In a playful way, it takes beginning guitar players through various levels where you’re challenged to play chords in order to entice all kinds of animals that’ve fled the zoo and lead them back. Also, its built-in tuner is truly genius. Highly recommended for beginning guitar players like myself. If you’re not convinced, have a look at Ovelin’s pitch for the game at Slush2011.

Aelios

Aelios is a polished weather app. It has quite a unique user interface which isn’t always the easiest, but it’s pretty and it works. It gets updated now and then, and useful new features like bookmarking locations were just added.

Prompt

Prompt is a Terminal client which can connect via SSH and supports color and fancy key combinations. Can be very handy for remote work, especially if you attach a bluetooth keyboard.

Penultimate

Penultimate is a drawing/note-taking app. It was the first app I bought. I’ve used it in the beginning, and found it to be ideal for quick sketches, not so much for text.

Air Video

Air Video can stream video from your Mac to iOS devices. It needs a ‘server’ package on the Mac side, which is a free download. It can transcode streams on-the-fly from pretty much every format you can find. One thing it cannot do (yet) is streaming of (physical) DVD’s.

GarageBand

GarageBand. What else do I need to say? I wasn’t convinced when I read about it, you just have to experience it. Excellent value for money if you’re at least a bit interested in music production.

iMockups

iMockups is a tool for quick user interface sketching using pre-fab elements like input fields and windows. It’s quite limited and I prefer doing mockups in straight HTML and CSS these days. Still, it’s a useful app that I would recommend especially to non-technical people who want to communicate their idea of an interface.

SketchBook

SketchBook Pro is a full featured drawing app. Gallery here. It has layers and loads of brushes, color management et cetera. Recommended even if you’re only drawing snow men while riding the train.

Pages

Pages is the only of the three iWork for iOS apps (Keynote and Numbers) I’ve bought, and it doesn’t disappoint. It does everything I expect of a wordprocessor. Since iCloud support was added, even the syncing problems have disappeared.

iMAME

iMAME is an Arcade emulator (MAME) formerly available only on jailbroken devices. More here

Snapseed

Snapseed is a Photo retouching app from Nik Software. They build expensive Photoshop plugins too, and this shows in the quality of Snapseeds filters and effects. The touch interface is a pleasure to use, especially on the iPad. Next level interaction design in my opinion.

I’m convinced that in the very near future, driven by gaming, WebGL will be available in all major webbrowsers and on most platforms.

This will open the door for 3D simulation like this right in the browser:

If you’re running the dev channel of Chrome or a nightly build of Webkit, have a look at Craftscape. Or try one of the WebGL experiments.

Derek Webb wrote an insightful post on why he as a musician prefers piracy to Spotify. In short, he gets paid $0.00029 per stream of a song played, versus a dollar per sell on iTunes for example. He claims that using Spotify gives a false sense of justification as opposed to piracy, where you know that what you’re doing is potentially harmful to the artist.

Those who claim that the absence of paid artists would lead to less art do not understand creativity: people will always create, it is a compulsion, the only question is whether they can do it for a living.

Fortunately it won’t come to this. There are many alternative ways to reward artists. The simplest is voluntary payment. This is an extension of the patronage system which was frequently used to reward artists prior to copyright, where a wealthy person would fund an artist to allow them to create full-time. The Internet permits an interesting extension of this idea, where rather than having just one wealthy patron, you could have hundreds of thousands, contributing small amounts of money over the Internet.

My idea for Spotify is simple yet powerful: On top of the Spotify Unlimited monthly fee, add a ‘Donation button’ which behaves like the Facebook Like-button or Google’s +1, and directly donates a pre-set amount of money (default of 1 dollar) to the musician. This would be easy to implement because a creditcard is already linked to your Spotify account.

It can even imagine this taking a social turn, where your donation appears in your Facebook’s timeline: “I’ve donated one dollar to 50 cent”.

Here’s some extra sketches by Mike Bostock (author of D3) I found on the D3.js Google Group:

• Voronoi Tessellation
• Voronoi Tessellation (Interactive)
• Rainbow Colors
• Stroke Dasharray
• Moire Patterns
• Force-Directed States of America
• Date Ticks
• Venn Diagram using Opacity
• Line Tension
• External SVG
• Dynamic Node Tree

TL;DR; Watch the demo.

I found World Light (world-light.mbtiles, 1220MB) from the great folks at MapBox.

It’s in MBTiles format (full spec, based on SQLite, for easy offline use).

Recommended tileservers are Tilestache (Python) and tilelive.js / TileStream (both for Node.js)

This works well, and Mapnik/GDAL is a powerful combination of mature software projects. There’s one obvious downside though: interactivity. The serverside rendered images are static in itself. OpenLayers handles a lot of stuff, like custom tile loading, markers and boxes, but there’s a trend in other frameworks to do a lot more in terms of clientside interactivity:

Leaflet

Leaflet by CloudMade is one of them, supporting tile layers, polylines, polygons, circles, markers, popups, image overlays, WMS layers and GeoJSON. Interactive features include ‘drag panning’, ‘scroll wheel zoom’, ‘double click zoom’, ‘shift-drag zoom to bounding box’ on the Desktop, and ‘Touch-drag panning’, ‘Multi-touch zoom (iOS only)’, ‘Double tap zoom’ and ‘Panning inertia’ on mobile browsers (iOS, Android). Another interesting feature is CSS3 styling of popups.

The code is on Github: https://github.com/CloudMade/Leaflet.

Rotary Maps

Another interesting clientside Javascript/SVG mapping library is Rotary Maps. It combines RaphaelJS with the V3 Google Maps API to layer vector graphics on top of the map.

Code also on Github: https://github.com/thumbtack/rotarymaps

The Wax documentation discourages the use of OpenLayers because it’s excessively complex and bloated for most map operations. It warns against the use of Polymaps because its SVG engine is not supported by IE7. So then what are we supposed to use? Apparently, Modest Maps is the library of choice. It was initially written in Actionscript, and ported to Python and Javascript.

Modest Maps features a simple interface with stuff like touch controls for mobile devices, fullscreen mode, a nice point-selector, a zoombox and more.

Unfortunately, Modest Maps can currently show only one layer, unlike OpenLayers. That’s why I especially like the combination with Leaflet. This allows layering and more of the functionality found in OpenLayers. Have a look at the demo, and try zooming on the map. It’s feels as smooth as some of the Silverlight demos I’ve seen.

So Wax integrates and extends several pieces of mapping software. Highly recommended for use when OpenLayers is deemed too heavy.

I used OS X briefly when it came out, and the potential of running software like Final Cut, Photoshop and Illustrator alongside UNIX tools like Apache and Python was quite promising. So when Tiger was released I didn’t wait and bought a Macbook. I was also lucky enough to get to work with OS X and Textmate at Eight Media, doing Django and front-end development. This kick-started my professional use of OS X.

After a while, some downsides emerged: OS X is quite unlike Linux. OS X is certainly more polished in its interface compared to KDE and Gnome, thanks to years of consistent UX history and adherence to the Apple HIG. Also, it’s really plug and play, and the system really goes to sleep when the lid is closed. These are important details to me.

But there are significant and infamous shortcomings: there’s no proper package management system. Forget Macports, try Homebrew if you must, but for your UNIXy development stack, it falls short. It’s no match for something like Aptitude.

I’ve come to the conclusion that the development stack should mirror the deployment stack as much as possible. That would be Ubuntu Linux, so I’ve tried running a full Ubuntu install in Parallels Desktop and VMWare Fusion, both of which are fantastic products that even provide 3D acceleration and a seamless experience (especially with Parallels’ coherence mode).

But since I don’t really need another window manager (as I said, OS X + Quicksilver does this just fine), a so-called ‘headless’ virtual machine would do the trick, too. VirtualBox supports this mode of operation. Some bright spirit went even further to integrate a headless VM into OS X, and created a Ruby tool called Vagrant.

What’s Vagrant you ask? I couldn’t say it more concise than they do on their website:

‘By providing automated creation and provisioning of virtual machines using Oracle’s VirtualBox, Vagrant provides the tools to create and configure lightweight, reproducible, and portable virtual environments’

In practice, I use Vagrant as such:

• I keep a directory in my OS X home directory (~) called VM/. This is where I run several VMs for different purposes. One for Django stuff, one for experimenting with GIS, one for trying out weird Linux tricks that could potentially destroy the system.
• I start with a base box (Ubuntu Lucid, a distro I use on the server, too) and tune it with ‘recipes’ using Chef (or Puppet). I then ‘repackage’ this VM for private re-use. (it gets stored in ~/.vagrant/boxes/, next to the baseline boxes).
• Recipes define what kind of software gets installed and configured by default, such as apache2-worker-mpm, nginx, postgresql with certain roles, et cetera.
• The configuration of each VM is stored in a Vagrantfile. This includes the shared folder location, port-forwarding, IP address, number of CPU’s and memory size. I run the VMs in the 33.33.33.x range. Someone told me this was a good idea, can’t remember who that was.
• In ~/VM/ubuntu_django/, I can run vagrant ssh, and a fully automated local SSH login occurs.
• The shared folder, specified in Vagrantfile, gets exported via NFS. This means I get access to /vagrant/projects/ on the VM side, which is the same as the directory ~/VM/ubuntu_django/projects/ in OS X. This is great, and allows me to use Textmate or any other editor or IDE while running the software in true Linux.
• The PostgreSQL recipe even automatically modifies the pg_hba.conf file to allow connections from outside, so I can use the GUI tool PGAdminIII from OS X to administer the postgres instance on Ubuntu.
• Using commands like vagrant up, vagrant halt, vagrant suspend and vagrant resume, I can manage the various VMs from the commandline.

Conclusion: OS X with VirtualBox managed by Vagrant gives me the best of both worlds in terms of operating systems. I still use Parallels for testing on Windows and the occasional peek at Gnome’s desktop though.