• Home
• About
• Articles
• Contact
• Downloads
• Glossary
• Links
• Projects

Synchronoptic timelines

Posted on April 22, 02010
Filed Under DaVinci, Journal | Leave a Comment

A synchronoptic timeline is one in which several timelines are displayed concurrently. The earliest recognised example dates from 1753 and is the work of the French physician Jacques Barbeu-Dubourg.

His Carte chronologique was produced on a scroll some 54 feet long, and at a scale of one year per tenth of an inch, it spanned the 6,480 years since the creation. Onto this Barbeu-Dubourg plotted a number of thematic timelines. Notable persons are annotated with iconography denoting their profession and social or religious status.

A contemporary of Barbeu-Dubourg was the English chemist Joseph Priestley who produced a number of synchronoptic timelines during his lifetime, including several editions of his New Chart of History.

The Afghan Conflict: A map of possible scenarios offers a modern take on the synchronoptic timeline. Instead of documenting the past Marc Tiedemann has charted a number of possible futures for the Afghan Conflict. The scenario timeline is available as a 164cm x 70cm printed poster and also as an interactive presentation on Prezi.

Hacking the Date class for GeoLocation

Posted on April 23, 02009
Filed Under DaVinci, Development, Drake, Flash, Journal, Projects, Timelines | 1 Comment

The demo above attempts to locate your current position on the earth. I can't take any credit for the 3D stuff as I based it on Andy Zupko's great post about Geolocation in Papervision3D. My little contribution is the code below. This takes the humble Date class and does some reverse engineering on it to derive your approximate location on the earth. First the code, then I'll explain how it works...

// Estimate Latitide and Longitude from the Date class.
var latitude:Number
var longitude:Number
var now:Date = new Date()
var northernWinter:Date = new Date( 2000, 0, 1 )
var northernSummer:Date = new Date( 2000, 6, 1 )
var northernWinterOffset:Number = northernWinter.timezoneOffset
var northernSummerOffset:Number = northernSummer.timezoneOffset

// Find just the Timezone modifier TZD (in minutes).
// DST modifier is negative so TZD is the larger value.
var tzd:Number = Math.max( northernWinterOffset, northernSummerOffset )

// if you need the current value of DST (in minutes) it's...
var dst:Number = now.timezoneOffset - tzd

// Estimate Longitude:
// 60 minutes of time == 15 degrees of longitude.
longitude = tzd / -4

// Estimate Latitude:
// If DST is adopted we can detect the current season and from that we can find the hemisphere. If not assume equatorial.
if ( northernWinterOffset == northernSummerOffset )
{
  // equatorial
  latitude = 0
}
else if ( northernWinterOffset > northernSummerOffset )
{
  // northern hemisphere
  latitude = 45
}
else
{
  // southern hemisphere
  latitude = -45
}

// and the estimates are...
trace( "Longitude: " + longitude )
trace( "Latitude: " + latitude )

Last year I wrote a series of posts that looked Inside the AS3 Date class. One of the gotchas I mentioned was the confusingly named .timezoneOffset property which is actually comprised of two offsets: timezone designation (TZD) and Daylight Saving Time (DST). In the article I showed some code that split these values back out again. Well it struck me the other day that you can use these values to approximate a users position on the earth. The cool thing about this hack is that it relies solely on understanding the mechanics of timezones and daylight saving, so itl will work just as well in Javascript as it does in AS2 or AS3.

If you follow the code above you'll see the first thing we do is split out TZD and DST. Once you have these values you can make some estimates about latitude and longitude.

TZD ≈ Longitude
The earth rotates once on it's axis each day so that's 360° in 24 hours, or 15° of longitude every hour. So if we know a user's TZD we can estimate their longitude (east/west) to within about 15°. In reality timezone boundaries are a little wobbly so I'd gave or take another 15°.

DST ≈ Latitude
Using DST to estimate latitude is really inaccurate but if you need to know then this way is better than nothing - here's the theory anyway. As a general rule Daylight Saving Time is adopted by countries with temperate climates. Employing it nearer the poles is pointless and the last thing you need at the equator is more sunshine. In the code above we created a summer and a winter date. By comparing these we can tell if the user's current location employs DST and if it is currently in effect.

There are plenty of special cases for DST (don't get me started on that) but if no DST offset exists in summer or winter then the user is probably within the equatorial band. If DST exists but is not in effect then that hemisphere is in winter, and the opposite hemisphere is in summer. A quick check against the current date will tell you which hemisphere that temporal band is in.

Caveat Emptor
So there you go, GeoLocation using just the Date class. I'm the first to admit that determining latitude is really inaccurate so if you need to know for sure then use server side IP Location. If accuracy is less important then this method is small, self contained and works in AS3, AS2 and Javascript. One last piece of trivia before I finish up; although I said employing Daylight Saving Time near the poles is largely pointless, it turns out that for reasons of synchronicity most Antarctic survey stations follow the DST rules for their home country.

Projects update March 2009

Posted on March 9, 02009
Filed Under DaVinci, Development, Flash, Harrison, Journal, Latham | Leave a Comment

I've made a few changes and updates to the site over the last few weeks. I thought it might be worth posting a quick update.

Da Vinci
This project now has it's own page and the BaseComponent class is checked into the repo. I've made a couple of updates to the code since the ahem, "finished" version I posted a few months back. Firstly I've added Grant Skinner's EventDispatcher optimization. And the second is a workaround for a weird bug in the Flash Player.

It turns out that a stage resize can fire the ADD_TO_STAGE Event twice. This causes the BaseComponent init() to be called twice. I didn't notice it when working with components on the Flash timeline but it becomes really obvious if you use it on an Actionscript only project in FlexBuilder. The fix is to remove the listener after the first event is fired.

Harrison
This project also has it's own page and the Timekeeper class is in the repo now as well. I've built a new combined example to go along with it. If you're interested in music sequencing you might like to check out Studio Anuirin's remixed version of the Timekeeper class.

Latham
This is the current project I'm working on. The first two base classes are built and they happily pass all the unit tests I can throw at them. Although it's early days for this one I'm inclined to open it up as soon as possible to get some feedback. I'll put a proper post together about it soon.

Big History

Posted on February 25, 02009
Filed Under DaVinci, Development, Flash, Herodotus, Inspiration, Journal, Latham, Projects, Timelines | Leave a Comment

When I came up with the fanciful notion of an interactive timeline that stretches back as far as the Big Bang I thought I was onto something exciting and new. The problem with new ideas these days though, is that you're only one quick web search away from the realisation that they are anything but.

Although I think the interactive visualisation aspect is still new, it turns out that the unified (multi-disciplinary) approach to history has been around for about 25 years. The study of Big History attempts to combine the timescales of cosmology, geology, paleontology, archeology and history into a single unified timeline. As we have more detailed information about events closer to the present, the result is a naturally logarithmic timeline.

Big History courses have been taught in Australia and the US and David Christian's excellent lecture series is available from the Learning Company. The information and insights contained in these books are going to be invaluable for structuring periodization for Herodotus.

The project architecture

Posted on February 16, 02009
Filed Under Bede, DaVinci, Development, Drake, Flash, Harrison, Herodotus, Journal, Kepler, Latham, Projects | Leave a Comment

After reviewing what I want to achieve from the project I have identified seven areas I need to work on. Each area will become its own project and is named after a major figure in that field. The plan is to post about the work here and check in newly completed functionality into http://code.google.com/p/computus/ .

The Model View Controller declarations in the diagram below are only intended to be broadly indicative of the functionality. As you'll see most of the work falls into the Model domain as it involves managing historical data. This should be good news for anyone wanting to use this work elsewhere. Although I'll be using Flash to build my UI, all of the model classes will be in pure AS3; meaning they can be used as-is in Flex or AIR (and with a bit of fiddling, converted to Javascript).

Much of last years work falls easily into the new structure. The Timekeeper class becomes part of Harrison, a project focusing on timekeeping in AS3. The Flash BaseComponent class will form the foundation of the user interface, a project that could only be named after Da Vinci, the archetypal artist/engineer.

Herodotus concerns itself with the accumulation and management of historical data. Named after the first ever historian this project will focus on importing and parsing all kinds of temporal data.

The twin project to Herodotus will be Bede. This is a project concerned with the generation of temporal data. These classes will principally be used to calculate the dates of movable feasts and other days of observance.

Both Herodotus and Bede will make use of the calendrical framework Latham. This project is named after the late Lance Latham, who's Standard C Date/Time Library was one of the original inspirations for The Computus Engine. Latham will support the storage of historical dates and simplify conversion between different timescales and calendar systems. Algorithmic calendars will be the first to be supported.

Astronomical calendars will follow in Latham after the completion of Kepler. I find it ridiculous that we don't yet have an open source astronomical framework in Actionscript. It looks like Im going to have to build my own. I really only need to generate ephemeris data for the earth, sun and moon but hopefully this might be enough to jump start a full astronomical framework in AS3. This is the International Year of Astronomy after all.

The last part of the puzzle is Drake which concerns itself with spatial calculations, and geocentrics is a prerequisite for Kepler. I may not need to do much with this as there seems to be a fair bit of good geo code kicking around already - mainly due to the huge number of PV3D earth demos!

The diagram below shows how the different projects fit together.

keep looking »