Friday, January 23, 2009

[Gd] iGoogle's getting some changes under the hood

| More

iGoogle Developer Blog: iGoogle's getting some changes under the hood

If you've had a chance to look at recent gadgets documentation, or tried out the iGoogle developer sandbox, you're probably aware that gadgets.* is the new hotness. Sadly, the _IG_* methods are all that work in production.

Starting within the next month, iGoogle will be undergoing some significant behind-the-scenes changes. The first recipients will be gadgets in open syndication, which will gain support for gadgets.*. We've worked hard to make sure gadgets work properly with the new architecture, and gadgets that use _IG_* methods should still function properly. However, there are two things that you, as a developer, should note.

First, support for datatype=location is now deprecated, and you should use another method, such as the Google Maps API geocoder, for positional data.

Second, iGoogle will dynamically rewrite some HTML and JavaScript for faster loading and rendering times. While this is generally a good thing, some malformed HTML and JavaScript can cause problems. Make sure to wrap your JavaScript code as demonstrated by the following example to avoid many common issues:

<script type="text/javascript">
<!--
// js code goes here...
// -->
</script>
As always, if you have issues, let us know in the iGoogle Developer Forum.

Posted by Dan Holevoet, Developer Programs
URL: http://igoogledeveloper.blogspot.com/2009/01/igoogles-getting-some-changes-under.html

[Gd] Advanced 3D Warehouse search in SketchUp 7

| More

Official Google SketchUp Blog: Advanced 3D Warehouse search in SketchUp 7

If you are one of the millions of users who has visited the Google 3D Warehouse, you know it's bursting at the seams with models of every imaginable variety from lots of different sources. And it's getting bigger by the hour.

That's great, and all the more reason you should be using Advanced Search to zero-in on just the right model. Accessing this feature from a web-browser is easy - just click on the Advanced Search link. You can refine your search by title, description, author, quantity (single model or collection), and minimum rating. But let's say I'm working in SketchUp and I don't want to stop what I'm doing to launch Firefox.

Okay, not to worry, I can get the same results using SketchUp's built-in mini-browser or better yet, with some practice, using the Component Browser itself. Let's say I'm looking for window treatments for a house I'm designing. I start by selecting the 'Get Models' button, which opens the mini-browser in SketchUp.


If I just type "window" into the search-box, I get about 8,700 models. Now, I have to refine my results by clicking 'Advanced Search'. The simplest qualification I can do is to search for "window" in just the title. That narrows my results to about 850.

It turns out I know the names of a lot of manufacturers that have added their windows to the 3DWH, so I can further narrow by Author. So I can add a company - let's say 'Pella' - under Author. What's really neat is you can run an advanced search and then look at both the results and how the search appears in the search window, as below.

Here are some pointers to help improve search syntax. Also check out this help page
  • Field name (for example, "title") followed by a colon : and then term you are looking for... "window." Don't put a space between the colon and the next word.
  • To search in multiple fields, you just put a space and repeat for the next qualification. Note also that you can use the key term "is" to search for either a model or a collection, which is pretty cool.
  • If your field is more than one word, put quotes around it: e.g., title:"title:"Dropped Placemarks."
Now if I wanted to really get efficient, I could get all of this right from the Component Browser window that I know and love from previous versions of SketchUp! I go to the 'Window' menu and select 'Components' and can type in my advanced search terms.
  1. I type in "window" and hit enter (8300 - too many!)
  2. Put a space and "author:marvin" (ok, cool, that gives 820, but still too much)
  3. I know I want an open pane, so I put a space and type "title:picture" (we're getting there, 172 results)
  4. Finally, I know that I want a Casement frame, so I put a space and type "casement"

Voilà! 54 windows that meet my needs that I can toggle through using the arrow in the lower right of the Component Browser.

Posted by James Therrien, SketchUp Team
URL: http://sketchupdate.blogspot.com/2009/01/advanced-3d-warehouse-search-in.html

[Gd] Dev update: Weekly bug fixes

| More

Google Chrome Releases: Dev update: Weekly bug fixes

Google Chrome's Dev channel has been updated to version 2.0.158.0. This release fixes a few bugs. Most of the effort in the last week has been spent on passing layout tests that have been failing since we updated to a more recent version of WebKit; those changes may improve layout on some sites, but are mostly minor tweaks you won't notice. That's a roundabout way of saying, we probably didn't fix the issue that's been bugging you the most this week.

Find about the Dev channel and how to subscribe at http://dev.chromium.org/getting-involved/dev-channel.

The complete list of changes is available in the release notes.

--Mark Larson, Google Chrome Program Manager
URL: http://googlechromereleases.blogspot.com/2009/01/dev-update-weekly-bug-fixes_22.html

Thursday, January 22, 2009

[Gd] Welcome

| More

Google AJAX API Alerts: Welcome

This blog is intended to be a place to receive updates for a few of Google's AJAX APIs:
The updates will be short messages to notify of changes that are made to the APIs. Changes such as bug fixes, added features, or general updates. The title of these posts will be in the format:
[API1 API2][AlertType] - title

An example would be:
[Search][New Feature] - Added movie search

That way you can set up your own custom alerts for updates.

If you have any questions, please stop by the group
URL: http://ajax-api-alerts.blogspot.com/2009/01/welcome.html

[Gd] [Libraries][Update] - jQuery 1.3.1

| More

Google AJAX API Alerts: [Libraries][Update] - jQuery 1.3.1

jQuery was updated to 1.3.1
URL: http://ajax-api-alerts.blogspot.com/2009/01/librariesupdate-jquery-131.html

[Gd] Playgrounds and alerts

| More

Google AJAX APIs Blog: Playgrounds and alerts

I recently launched a new product to help developers learn our APIs. It's an open source framework for showing Javascript code samples. The tool allows users to click through samples so that they can edit code and see their changes live. In order to be a more practical tool for code editing, I put "save" and "export" features in there. You can read more about it on the official blog post.

I would also like to point you at a new blog the AJAX APIs team will be maintaining: the AJAX APIs Alert Blog. Whether you know it or not (or believe it or not!) we are constantly making changes to the APIs. New features, bug fixes, tweaks, etc. In the past we haven't had a way of communicating these changes to you since they can be small changes and not worth a whole blog post here. Furthermore, there are those of you that want to know when we update the Javascript libraries that we host. So from here on out, that blog will be the new home for these "alerts". Posts will be short, to the point and we will try to update it with all public changes, so subscribe now!
URL: http://googleajaxsearchapi.blogspot.com/2009/01/playgrounds-and-alerts.html

[Gd] Year in Review

| More

Official Google Webmaster Central Blog: Year in Review

2008 was another great year for the Webmaster Central team. We experienced tremendous user growth with our blogs (97% increase in monthly pageviews), Help Center (25%), Help Forums (225%), and Webmaster Tools (35%). We would like to welcome our new users that joined us in '08, and thank our loyal and passionate user base that have been with us for the last couple of years. We focused on two basic goals for 2008, and here's how we think we did:

Goal #1: Educate and grow our webmaster community
  • We had our first ever online webmaster chat in February '08 to answer your top questions, and followed it up with three more. They have been incredibly successful, and we're planning for more this year.
  • We'd like to send a special thank you to our Bionic Posters, who have played a huge part in supporting our growing community.
  • Localization has been a big focus for us, so we launched our blog and Help Center in additional languages, and made Webmaster Tools available in 40 languages. We hope this makes it easier for people in other parts of the world to adopt our tools and gain a better understanding of how search works.
  • We launched a new Help Forum in English and Polish, with a broader rollout planned in other languages this year.
  • Our SEO starter guide was released and it has been one of our most successful articles to date.
  • We placed an emphasis on sharing material via YouTube and created seven video series totaling two hours of content. We kicked off '09 with a bang on the video front with Matt's "Virtual Blight" presentation.
Goal #2: Iterate early and often on Webmaster Tools
Thank you once again and we hope for another exciting and eventful year!

Written by Sagar Kamdar, Webmaster Tools Product Manager, in need of some Rock Band skillz
URL: http://googlewebmastercentral.blogspot.com/2009/01/year-in-review.html

[Gd] TotT: Keep Your Fakes Simple

| More

Google Testing Blog: TotT: Keep Your Fakes Simple

When scientists in California tried to raise condors in captivity, they ran into a problem. The chicks wouldn't eat from the researchers' hands; they wanted a mother condor to feed them. So the scientists got a puppet. To the chicks, it looked like their mother's head was feeding them—but inside was the same scientist's hand.

Consider a contrived example based on that:

TEST_F(BabyCondorTest, EatsCarrion) {
  FakeCondor mother;
  scoped_ptr carrion;
  BabyCondor* pchick = &chick_;
  mother.Imprint(vector(&pchick, &pchick + 1)); // just one chick
  while(!chick_.HasFood()) {
    mother.Eat(); // disposes of any food the mother kept for herself
    mother.Scavenge(carrion.reset(new FakeCarrion)); // finds new food
    mother.RandomlyDistributeFoodAmongYoungAndSelf(); // feeds baby or mom
  }
  chick_.Eat();
  EXPECT_TRUE(carrion->WasEaten());
}



Something is wrong here—that was a lot of setup! The general-purpose FakeCondor replicates too much functionality from the full class. The researchers' puppet didn't scavenge its own carrion, so why should ours? We just want to test that the baby Eats. We condense various motherhood behaviors, such as giving food, into single method calls by extracting a role interface. (If we couldn't change Condor, we would also write an adapter.)

class CondorMotherhoodRoleInterface {
 public:
  virtual Carrion* GiveFood() = 0;
  virtual SomeReturnTypes* OtherMomBehaviors() = 0;
};



Then we write a single-use fake which provides only behaviors we need for this particular test.

class CondorFeedingPuppet: public CondorMotherhoodRoleInterface {
 public:
  virtual Carrion* GiveFood() { return test_carrion_; }
  virtual SomeReturnTypes* OtherMomBehaviors() { return NULL; }
  Carrion* test_carrion_; // public var is tolerable in a one-off object
};

TEST_F(BabyCondorTest, EatsCarrion) {
  CondorFeedingPuppet mother; FakeCarrion test_carrion;
  mother.test_carrion_ = &test_carrion;
  chick_.ReceiveFood(&mother);
  chick_.Eat();
  EXPECT_TRUE(test_carrion.WasEaten());
}



This highly-focused fake is easy and quick to write, and makes the test much simpler and more readable. Don't overestimate the complexity of your dependencies! Often a very simple fake is the best.

Remember to download this episode of Testing on the Toilet and post it in your office.
URL: http://googletesting.blogspot.com/2009/01/tott-keep-your-fakes-simple.html

[Gd] Playing around with Google's AJAX APIs

| More

Google Code Blog: Playing around with Google's AJAX APIs

By Ben Lisbakken, Developer Programs Engineer

For me, documentation isn't always enough to learn about APIs; I need examples that I can play with. That's why I started a fun project recently--a tool for teaching developers how to use Google's JavaScript APIs: the AJAX API Playground. I have been working on this in my 20% time and today I am proud to announce that we are launching the AJAX API Playground as the official way that Google will show JavaScript samples!
The AJAX API Playground is currently loaded with over 170 samples for 8 Google JavaScript APIs (Maps, Search, Feeds, Calendar, Visualization, Language, Blogger, Libraries and Earth) that you can edit and run to help you explore what Google's APIs have to offer. There are also save and export features. The save feature allows you to hold onto an edited sample so you can continue working on it later, while export lets you modify a sample and publish the code to a permanent url.

As the AJAX API Playground is built on App Engine, you can create your own App Engine instance to show off your code samples. The code is open sourced under an Apache 2.0 license and uses several open source libraries and tools, including jQueryjQuery UIYUI Compressor, and CodeMirror. You can find the code on Google Project Hosting and learn about adding samples on the project wiki.

Stay tuned for more samples for more APIs. Enjoy!
URL: http://google-code-updates.blogspot.com/2009/01/playing-around-with-googles-ajax-apis.html

[Gd] Playing around with Google's AJAX APIs

| More

Google Code Blog: Playing around with Google's AJAX APIs

By Ben Lisbakken, Developer Programs Engineer

For me, documentation isn't always enough to learn about APIs; I need examples that I can play with. That's why I started a fun project recently--a tool for teaching developers how to use Google's JavaScript APIs: the AJAX API Playground. I have been working on this in my 20% time and today I am proud to announce that we are launching the AJAX API Playground as the official way that Google will show JavaScript samples!
The AJAX API Playground is currently loaded with over 170 samples for 8 Google JavaScript APIs (Maps, Search, Feeds, Calendar, Visualization, Language, Blogger, Libraries and Earth) that you can edit and run to help you explore what Google's APIs have to offer. There are also save and export features. The save feature allows you to hold onto an edited sample so you can continue working on it later, while export lets you modify a sample and publish the code to a permanent url.

As the AJAX API Playground is built on App Engine, you can create your own App Engine instance to show off your code samples. The code is open sourced under an Apache 2.0 license and uses several open source libraries and tools, including jQueryjQuery UIYUI Compressor, and CodeMirror. You can find the code on Google Project Hosting and learn about adding samples on the project wiki.

Stay tuned for more samples for more APIs. Enjoy!
URL: http://google-code-updates.blogspot.com/2009/01/playing-around-with-googles-ajax-apis.html

Tuesday, January 20, 2009

[Gd] Keyword Match Type and the KeywordToolService

| More

AdWords API Blog: Keyword Match Type and the KeywordToolService

We first blogged about AdWords API v13's new keyword search volume info functionality back in November, and it remains a popular topic among developers. We've heard a number of follow-up questions about how the results from v13's KeywordToolService match up with the results available via the corresponding web application, especially when it comes to issues regarding keyword match type. There are two different scenarios in which you might want to specify match type when retrieving keyword variations, and hopefully the information in this blog post will clear up some confusion as to how the KeywordToolService supports that functionality.

One scenario involves giving a hint to the keyword variation service as to what kind of query you want to use as the seed. If you're calling getKeywordVariations(), you use the type attribute of the SeedKeyword object to do this. So, for example, if you want to generate variations based on a phrase match for "baseball bat", you'd specify "Phrase" for the type attribute and "baseball bat" for the text attribute of the SeedKeyword. If instead of a phrase match you were interested in generating keyword variations based on a broad match, you'd instead specify "Broad" for the type attribute. The important thing here is that the type attribute can affect the specific variations that are returned. In the "baseball bat" example, most of the variation keywords that are returned are the same for the two match types, but there are some differences. For example, the variation "baseball training bat" is only returned when you specify a Broad match type.

The options outlined above directly translate into using the web version of the tool and specifying two different match types for the source keyword. In the section in which you're instructed to "Enter one keyword or phrase per line", if you were to enter the literal text "baseball bat" (with quotes) you'd specify a Phrase match type. If you entered baseball bat (without quotes) you'd specify a Broad match type. (An Exact match type is expressed as [baseball bat], i.e. with brackets around the text.)

This distinction only applies to the getKeywordVariations() method of the KeywordToolService. getKeywordsFromSite() doesn't allow you to specify a match type for the source keyword because there is no source keyword; instead, you're passing in a specific URL to use as the source, and a match type would not make sense in that context.

The second scenario in which you might care about match type involves the search volume results for each SiteKeyword or KeywordVariation object that is returned from getKeywordsFromSite() and getKeywordVariations(). The web version of the tool provides a popup menu in the results area allowing you to select the match type you're interested in. When you choose a match type, it will update the search volume information of each suggested keyword accordingly. Unfortunately, there is currently no way to retrieve search volumes for different match types using the API's KeywordToolService methods. The search volumes in the results returned from the API should roughly correspond to what you'd see with the Broad setting for match type in the web tool, but retrieving search volumes for Phrase or Exact match types is not possible.

--Jeffrey Posnick, AdWords API Team
URL: http://adwordsapi.blogspot.com/2009/01/keyword-match-type-and.html

[Gd] Avoiding memory leaks

| More

Android Developers Blog: Avoiding memory leaks

Android applications are, at least on the T-Mobile G1, limited to 16 MB of heap. It's both a lot of memory for a phone and yet very little for what some developers want to achieve. Even if you do not plan on using all of this memory, you should use as little as possible to let other applications run without getting them killed. The more applications Android can keep in memory, the faster it will be for the user to switch between his apps. As part of my job, I ran into memory leaks issues in Android applications and they are most of the time due to the same mistake: keeping a long-lived reference to a Context.



On Android, a Context is used for many operations but mostly to load and access resources. This is why all the widgets receive a Context parameter in their constructor. In a regular Android application, you usually have two kinds of Context, Activity and Application. It's usually the first one that the developer passes to classes and methods that need a Context:




@Override
protected void onCreate(Bundle state) {
super.onCreate(state);

TextView label = new TextView(this);
label.setText("Leaks are bad");

setContentView(label);
}


This means that views have a reference to the entire activity and therefore to anything your activity is holding onto; usually the entire View hierarchy and all its resources. Therefore, if you leak the Context ("leak" meaning you keep a reference to it thus preventing the GC from collecting it), you leak a lot of memory. Leaking an entire activity can be really easy if you're not careful.



When the screen orientation changes the system will, by default, destroy the current activity and create a new one while preserving its state. In doing so, Android will reload the application's UI from the resources. Now imagine you wrote an application with a large bitmap that you don't want to load on every rotation. The easiest way to keep it around and not having to reload it on every rotation is to keep in a static field:




private static Drawable sBackground;

@Override
protected void onCreate(Bundle state) {
super.onCreate(state);

TextView label = new TextView(this);
label.setText("Leaks are bad");

if (sBackground == null) {
sBackground = getDrawable(R.drawable.large_bitmap);
}
label.setBackgroundDrawable(sBackground);

setContentView(label);
}


This code is very fast and also very wrong; it leaks the first activity created upon the first screen orientation change. When a Drawable is attached to a view, the view is set as a callback on the drawable. In the code snippet above, this means the drawable has a reference to the TextView which itself has a reference to the activity (the Context) which in turns has references to pretty much anything (depending on your code.)



This example is one of the simplest cases of leaking the Context and you can see how we worked around it in the Home screen's source code (look for the unbindDrawables() method) by setting the stored drawables' callbacks to null when the activity is destroyed. Interestingly enough, there are cases where you can create a chain of leaked contexts, and they are bad. They make you run out of memory rather quickly.



There are two easy ways to avoid context-related memory leaks. The most obvious one is to avoid escaping the context outside of its own scope. The example above showed the case of a static reference but inner classes and their implicit reference to the outer class can be equally dangerous. The second solution is to use the Application context. This context will live as long as your application is alive and does not depend on the activities life cycle. If you plan on keeping long-lived objects that need a context, remember the application object. You can obtain it easily by calling Context.getApplicationContext() or Activity.getApplication().



In summary, to avoid context-related memory leaks, remember the following:



  • Do not keep long-lived references to a context-activity (a reference to an activity should have the same life cycle as the activity itself)

  • Try using the context-application instead of a context-activity

  • Avoid non-static inner classes in an activity if you don't control their life cycle, use a static inner class and make a weak reference to the activity inside. The solution to this issue is to use a static inner class with a WeakReference to the outer class, as done in ViewRoot and its W inner class for instance

  • A garbage collector is not an insurance against memory leaks



Note: This article was originally posted on my personal blog.

URL: http://android-developers.blogspot.com/2009/01/avoiding-memory-leaks.html

[Gd] When to use Dependency Injection

| More

Google Testing Blog: When to use Dependency Injection

by Miško Hevery

A great question from the reader...
The only thing that does not fully convince me in your articles is usage of Guice. I'm currently unable to see clearly its advantages over plain factories, crafted by hand. Do you recommend using of Guice in every single case? I strongly suspect, there are cases, where hand-crafted factories make a better fit than Guice. Could you comment on that (possibly at your website)?

I think this is multi-part question:

  1. Should I be using dependency-injection?

  2. Should I be using manual dependency-injection or automatic dependency-injection framework?

  3. Which automatic dependency-injection framework should I use?


Should I be using dependency-injection?

The answer to this question should be a resounding yes! We covered this many times how to think about the new-operator, singletons are liars, and of course the talk on dependency-injection.

Dependency injection is simply a good idea and it helps with: testability; maintenance; and bringing new people up to speed on new code-base. Dependency-injection helps you with writing good software whether it is a small project of one or large project with a team of collaborators.

Should I be using manual dependency-injection or automatic dependency-injection framework?

Whether or not to use a framework for dependency injection depends a lot on your preferences and the size of your project. You don't get any additional magical powers by using a framework. I personally like to use frameworks on medium to large projects but stick to manual DI with small projects. Here are some arguments both ways to help you make a decision.

In favor of manual DI:

  • Simple: Nothing to learn, no dependencies.

  • No reflection magic: In IDE it is easy to find out who calls the constructors.

  • Even developers who do not understand DI can follow and contribute to projects.


In favor of automatic DI framework:

  • Consistency: On a large team a lot can be said in doing things in consistent manner. Frameworks help a lot here.

  • Declarative: The wiring, scopes and rules of instantiation are declarative. This makes it easier to understand how the application is wired together and easier to change.

  • Less typing: No need to create the factory classes by hand.

  • Helps with end-to-end tests: For end-to-end tests we often need to replace key components of the application with fake implementations, an automated framework can be of great help.


Which automatic dependency-injection framework should I use?

There are three main DI frameworks which I am aware off: GUICE, Pico Container and Spring.

I work for Google, I have used GUICE extensively therefor my default recommendation will be GUICE. :-) However I am going to attempt to be objective about the differences. Keep in mind that I have not actually used the other ones on real projects.

Spring was first. As a result it goes far beyond DI and has everything and kitchen sink integrated into it which is very impressive. The DI part of Spring has some differences worth pointing out. Unlike GUICE or Pico, Spring uses XML files for configuration. Both are declarative but GUICE is compiled and as a result GUICE can take advantage of compiler type safety and generics, which I think is a great plus for GUICE.

Historically, Spring started with setter injection. Pico introduced constructor injection. Today, all frameworks can do both setter and constructor injection, but the developers using these frameworks still have their preferences. GUICE and Pico strongly prefer constructor injection while Spring is in the setter injection camp. I prefer constructor injection but the reasons are better left for another post.

Personally, I think all of the three have been around for a while and have proven themselves extensively, so no matter which one you chose you will benefit greatly from your decision. All three frameworks have been heavily influenced by each other and on a macro level are very similar.

Your milage may very.
URL: http://googletesting.blogspot.com/2009/01/when-to-use-dependency-injection.html

[Gd] Home delivery of Custom Search to webmasters

| More

Google Custom Search: Home delivery of Custom Search to webmasters

Posted by: Radu Cornea, Software Engineer and Rajat Mukherjee, Group Product Manager

Until today, when you wanted to add Google Custom Search to your site, you had to head directly to our Custom Search Engine site. Although creating your own Google-powered search engine only takes a few minutes, we thought it might be easier if we delivered this functionality right to where many of you manage your sites online. Choice is a beautiful thing.

If you own a website hosted on IPOWER, StartLogic, PowWeb, FatCow, BizLand, EasyCGI and several other web hosting providers, you can now configure Custom Search right in your hoster's management console - these hosters now support both Webmaster Tools and Custom Search. It's like having pizza delivered to your door instead of having to drive over to the pizza parlour!

When you sign up for the service, you get the following benefits, all from the comfort of your hoster's control panel:
  • a Google account is automatically created for you - you don't have to remember additional passwords or login to use these Google services
  • you can generate search engines for your websites by simply identifying your domains
  • shortcuts are provided to manage your Webmaster Tools account and your Custom Search Engines
  • Sitemaps for URLs on your sites can be automatically submitted to Webmaster Tools for better indexing on Google.com
  • your Custom Search engines will automatically recognize and use the submitted Sitemaps for enhanced indexing coverage
  • you can make money by associating your Adsense publisher ID with your search engines and sharing advertising revenue with Google
  • you can upgrade your search engines to use Site Search for further control over branding, presentation (via XML results) and On-Demand indexing


If your site is hosted by one of the above providers, give it a try - go to your hoster's console and add a search box to your site if you don't already have one. High quality search improves user experience, and also directly increases user engagement and improves conversions on web sites.

Additionally, let us know if there are things about this integrated service offering that we can improve. Our programmer's guide provides more details about the new Custom Search APIs that allow programmatic creation and management of Custom Search engines. If you are a web site hoster interested in incorporating these Google webmaster services into your platform, please contact us.
URL: http://googlecustomsearch.blogspot.com/2009/01/home-delivery-of-custom-search-to.html

Monday, January 19, 2009

[Gd] Virtually experience the Inauguration

| More

Official Google SketchUp Blog: Virtually experience the Inauguration

Earlier today, the Lat Long blog posted some tips about how to use Google Maps to be prepared for tomorrow's Inauguration. Well, for those who aren't able to take in the historic event in person, our own 3D data specialist Nathan Kohrmann put together an amazing model of the Inauguration venue -- the US Capitol Building.



Visit the Google 3D Warehouse where a full scale replica of the 2009 Inaugural Stage is ready to be explored... complete with Barack Obama taking the oath! With Google Earth installed, click "Download Model" to instantly import the stage into a fantastic 3D view, then let the fun begin. Zoom in close to where Barack Obama is standing on the stage to take in the exact view he has or swoop down to the National Mall to see what millions of other spectators are watching.

News.com.au has also put together a great Street View "walking tour" of the Inaugural Parade route, which is another great way to feel like you're a part of the festivities no matter where you are.

Posted by Elaine Filadelfo, Lat Long Blog Team
URL: http://sketchupdate.blogspot.com/2009/01/virtually-experience-inauguration.html