It has been almost two months now, and I’ve been making regular visits to my yard, working away bit by bit, stopping when my yard waste container is full.   As I’ve been weeding, dead-heading, raking, and trimming, I have realized something quite amazing.  Each time I take on work in the yard, I feel a strange sense of calm come over me, and I unintentionally end up losing hours in it.  Put simply, I love it.

This is somewhat uncharacteristic of me, so I have been meditating on why it is that I find myself so feeling so fulfilled while working in the yard.  Certainly it could just be that I’m getting older and more mature, but I find such explanations to be unsatisfying.  The truth that I have come to realize is that it gives me an opportunity to view life from a completely different perspective, one of plants and bugs.

While working in the yard all of my concerns in life seem less pressing.  To be clear, they do not go away as if being ignored in favor of distracting myself with something else, but rather they simply seem to loosen their grip on me.   I can spend hours quietly contemplating my life, and all the things I normally would; but given the continually surprising perspective on life that I run into, it’s much harder to get bogged down under the apparent weight of it all.

Working in my yard I am able to connect with life in ways that I rarely get to otherwise.  I now better understand why so many great minds find comfort in gardening.  What a fantastic venue for quiet meditation and exercise.

What are Implicit Types?

// Explicit
List<string> userNames = new List<string>();

// Implicit
var userNames = new List<string>();

Implicit types in C# are basically placeholder types that the compiler figures out for you. They may hold any type to begin with, but once they are assigned a value of a certain type, that type is noted by the compiler and will error if you try to assign a different type later.

// Okay! quote is being assigned a string value
var quote = "Things that try to look like things often do look more like things than things.";

// Compile Error! Cannot convert source type 'float' to target type 'string'
quote = 4.0f;

When are Implicit Types Bad?
The use of implicit types becomes a problem when a type cannot be determined without access to external or non-local bits of code. Here’s an example of what I mean; are you able to tell me what type will be printed to the console below assuming that the elem is valid?

// Allow the compiler to determine the type
var elem = _listOfElements[idx];

// What type will be printed here?
Console.WriteLine(elem.GetType());

When are Implicit Types Useful?

The thing I’ve found implicit types most useful for is saving keystrokes and making refactoring large swaths of code easier.  Consider the following example to illustrate why this can be useful. It is notable that if you’re the compiler, these statements end up being exactly the same.

// Explicit
Dictionary<string, Luggage> thisDict = new Dictionary<string, Luggage>();

// Implicit
var thatDict = new Dictionary<string, Luggage>();

Not only does the implicitly typed variable take fewer keystrokes to type out initially, but if you have to change the type of the variable at a later point you only need to change it once, rather than changing it on both sides. The real impact here is time saved when changing tens or hundreds of occurrences of complex type variables like this across many files.

Two Rules.

I mentioned at the top that I had come up with two rules for making sure that you get all the upsides and none of the downsides of implicit typing, so here they are:

1. Only use implicit typing when the type can be readily determined by looking at the local context surrounding the line.

2. Never use implicit types on numbers.

By following these two simple rules, you’ll reduce the number of keystrokes you have to type, as well as maintain the ability to determine the type correctly without Intellisense (e.g. Code snippets in a webpage.)

Positioning Elements in Code

With a Canvas you’re almost always going to want to have some code that positions the child elements.  To move things about, the property you are concerned with is not, as you might expect, a Position or Left/Top property on the child element, but rather it is a property of the Canvas that can be set on a child element.

There are two ways I have seen used to set the Canvas.Left or Canvas.Top property on a child element, and in some cases you’ll want to distinguish between the two.

The first way is to call SetValue on the Child element with the DependencyProperty you want to set, Canvas.LeftProperty or Canvas.TopProperty.   The second way is to call Canvas.SetLeft or Canvas.SetTop and pass in the UIElement to set it on.

When Speed Matters

In some situations it can be helpful to understand the difference in performance of the various ways of setting these properties.

I could not find any information comparing the performance of these two methods so I wrote a small unit test (below) that could tell me which was faster.  It turns out that on average, calling the Canvas.SetLeft/SetTop methods are about 3 times faster than calling Element.SetValue with the DependencyProperty.

When you think about that for a moment, it begins to make sense, because the Element.SetValue method takes a DependencyProperty and a value, which means that it resolve the property to end up at it’s destination.  On the other hand the SetLeft/SetTop methods already know what data they’re setting (they even explicitly specify it in the naming!), which means they should have a pretty direct path to the data.

Testing Performance

I’ve provided below the source code that I used to generate the data for this graph so you can try it for yourself.

public void TestCanvasElementPositioning()
{
   long elapsedSetValueTop = 0;
   long elapsedSetTop = 0;
   long elapsedSetValueLeft = 0;
   long elapsedSetLeft = 0;
   var timer = new Stopwatch();

   var testCanvas = new Canvas();
   var testChild = new Ellipse();
   testCanvas.Children.Add(testChild);

   // How many iterations to time
   const long iterations = 10000;

   // Canvas.SetLeft
   timer.Start();
   for (int i = 0; i < iterations; i++)
      Canvas.SetLeft(testChild, (double)i % 10);
   timer.Stop();
   elapsedSetLeft = timer.ElapsedMilliseconds;
   timer.Reset();

   // Element.SetValue(Canvas.LeftProperty)
   timer.Start();
   for (int i = 0; i < iterations; i++)
      testChild.SetValue(Canvas.LeftProperty, (double)i % 10);
   timer.Stop();
   elapsedSetValueLeft = timer.ElapsedMilliseconds;
   timer.Reset();

   testCanvas = new Canvas();
   testChild = new Ellipse();
   GC.Collect();

   // Element.SetValue(Canvas.TopProperty)
   timer.Start();
   for (int i = 0; i < iterations; i++)
      testChild.SetValue(Canvas.TopProperty, (double)i % 10);
   timer.Stop();
   elapsedSetValueTop = timer.ElapsedMilliseconds;
   timer.Reset();

   // Canvas.SetTop
   timer.Start();
   for (int i = 0; i < iterations; i++)
      Canvas.SetTop(testChild, (double)i % 10);
   timer.Stop();
   elapsedSetTop = timer.ElapsedMilliseconds;
   timer.Reset();

   Assert.IsTrue(elapsedSetLeft < elapsedSetValueLeft,
                 "Expected SetLeft to be less than SetValue");
   Assert.IsTrue(elapsedSetTop < elapsedSetValueTop,
                 "Expected SetTop to be less than SetValue");
}

MetadataSample.cs

The sample below shows how to specify a custom Attribute called “SomeExtraData”, use it on a class “SomeClass” and retrieve the custom data in code for further use.

using System;
using System.Diagnostics;

namespace SilverShorts
{
   // This class makes the [SomeExtraData] tag below valid
   class SomeExtraData : Attribute
   {
      public string SomeField;
   }

   // Tag this class with a custom attribute
   [SomeExtraData (SomeField="SomeValue")]
   class SomeClass
   {
      public SomeClass()
      {
         // Retrieve the value of the SomeField item in the metadata
         // tag on this class.
         Type t = typeof(SomeClass);
         SomeExtraData attr = t.GetCustomAttributes(false)[0] as SomeExtraData;
         Debug.WriteLine("SomeExtraData.SomeField = " + attr.SomeField);
      }
   }
}

A word of caution: Be aware of how often you perform operations like querying custom attributes in the constructor above.  The system reflection calls can negatively impact performance if you abuse them. I won’t preach about it, just use them only when you need to.

For this post I want to go over the code that I created for doing a Bing image query, to demonstrate just how powerful and concise Silverlight 3 C# code can be. To truly appreciate this, I suggest checking out the code, which totals about 225 lines for both the Image Search utility AND the Test Application.

To get started, let’s enumerate the requirements I came up with for the project:

1. Image Search
   • Bing Image query based on textual search terms
   • Transform XML results into custom classes

We’ll refer back to these requirements as we build the code to make sure we stay on track.

Image Search

The image search has two parts, performing the query, and processing/returning the results.  C#, Silverlight, and LINQ to XML will make this a pretty trivial task for us.

We’re going to start by creating a static class to contain our image query code.  We’re creating a static class in this case because we will have no member data to store, and will have only one public method (Search) to access.  Here’s what it will look like as an outline, notice that it appears to conform to the goals for #1 above, that is, in its definition it contains a method for performing a query, and a private method for processing the results.

namespace djc.SilverShorts.Bing
{
   public class ImageResult {}
   static class ImageQuery
   {
      #region Public Search Interface
      public delegate void SearchResultCallback(List<ImageResult> results);
      static public void Search(string appId, string search, SearchResultCallback callback, int numImages = 10, int offsetIndex = 0, bool useSafeSearch = true) {}
      #endregion

      #region Xml to Object LINQ
      static private void _processXmlResults(string xml, SearchResultCallback callback) {}
      #endregion
   }
}

Bing Image query based on textual search terms

First we need to create a formatted Url string that the Bing service can understand, then we need to create a WebClient object and use it’s DownloadStringAsync method to perform the query.  Once we’ve done this, our new Search method looks like so:

      static public void Search(string appId, string search, SearchResultCallback callback, int numImages = 10, int offsetIndex = 0, bool useSafeSearch = true)
      {
         string requestString = "http://api.bing.net/xml.aspx?"
             + "AppId=" + appId
             + "&Query=" + search
             + "&Sources=Image"
             + "&Version=2.0"
             + "&Market=en-us"
             + (useSafeSearch ? "&Adult=Moderate" : "")
             + "&Image.Count=" + numImages.ToString()
             + "&Image.Offset=" + offsetIndex.ToString();
         Uri uri = new Uri(requestString, UriKind.Absolute);
         WebClient client = new WebClient();
         client.DownloadStringCompleted += _downloadStringCompleted;
         // Note that we're passing the callback delegate as user data
         client.DownloadStringAsync(uri, callback);
      }

We’ve got a few hardcoded bits in here. For a more complete Bing query API implementation, see Bing Sharp.

The astute reader will note that we’ve registered a callback event handler function called _downloadStringCompleted that doesn’t exist in our initial class outline.  We’ll need to create this and use this event handler to trigger our _processXmlResults method.  We’ll make sure there was no error in the network query, and that a valid callback has been specified, then hand off control to our second bit of code that will transform the XML into custom class data.

      static private void _downloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
      {
         SearchResultCallback callback = e.UserState as SearchResultCallback;
         if (e.Error != null || callback == null)
            return;

         _processXmlResults(e.Result.ToString(), callback);
      }

Transform XML results into custom classes

At this point we’re ready to get into parsing the Bing XML string into custom class data. Before we get there, let’s take a look at what the XML we’re going to be parsing will look like.  This structure will also inform how we implement our custom classes to hold the information we’ve retrieved.

Bing Result XML Example

<?xml version="1.0" encoding="utf-8" ?>
<?pageview_candidate?>
<SearchResponse xmlns="http://schemas.microsoft.com/LiveSearch/2008/04/XML/element" Version="2.0">
   <Query>
      <SearchTerms>Waffles</SearchTerms>
   </Query>
   <mms:Image xmlns:mms="http://schemas.microsoft.com/LiveSearch/2008/04/XML/multimedia">
      <mms:Total>1200000</mms:Total>
      <mms:Offset>0</mms:Offset>
      <mms:Results>
         <mms:ImageResult>
            <mms:Title>Thank goodness for waffles</mms:Title>
            <mms:MediaUrl>http://www.digsmagazine.com/images/nourisharticles/waffles.jpg</mms:MediaUrl>
            <mms:Url>http://dwoolstar.blogspot.com/2005_05_01_archive.html</mms:Url>
            <mms:DisplayUrl>http://dwoolstar.blogspot.com/2005_05_01_archive.html</mms:DisplayUrl>
            <mms:Width>150</mms:Width>
            <mms:Height>200</mms:Height>
            <mms:FileSize>6895</mms:FileSize>
            <mms:Thumbnail>
               <mms:Url>http://ts1.mm.bing.net/images/thumbnail.aspx?q=1383735232706&amp;id=4778a42319f15e572deaa592c12334c5</mms:Url>
               <mms:ContentType>image/jpeg</mms:ContentType>
               <mms:Width>120</mms:Width>
               <mms:Height>160</mms:Height>
               <mms:FileSize>4218</mms:FileSize>
            </mms:Thumbnail>
         </mms:ImageResult>
      </mms:Results>
   </mms:Image>
</SearchResponse>

Now that we see the general information available to us, it’s time to go back to our empty ImageResult class that we defined above, and give it some meat. We’re only concerned with the ImageResult elements and their children in this case, so we’ll copy them pretty directly. The result looks like this:

Custom ImageResult class

   public class ImageResult
   {
      public string Title;
      public string MediaUrl;
      public string Url;
      public string DisplayUrl;
      public int Width;
      public int Height;
      public int FileSize;
      public class Thumbnail
      {
         public string Url;
         public string ContentType;
         public int Width;
         public int Height;
         public int FileSize;
      }
      public Thumbnail Thumb;
   }

Take a moment to look over the two codeblocks above and note the similarities in structure. Once you see it, continue to the codeblock below and try to recognize the same similarities in structure.

NOTE: It’s important to note that the C# classes I have do NOT need to have a direct mapping of member variable names to the XML elements we’ll be pulling data from.  To make this more clear, consider that the XML element for a thumbnail is “Thumbnail”, and our custom class variable is called “Thumb”.  Consider further that I could have called it SmallImage, Pinkynail, Luggage, or anything else and accounted for it accordingly in the LINQ query below.

Using LINQ to transform XML

Finally we’re to the point that we’re ready to take our XML and turn it into something that we can use in our Silverlight application somewhat generically.  Let us take a staged-approach to understanding the final, complex, nested query.  First we’ll look at a simpler query, then a more complex query, and finally we’ll put it all together into the actual query that jives with our intention and requirements.

A Simple Query

To better understand the final more complex query, let us consider a simpler query that doesn’t have a nested sub-query for thumbnails, and also does not have namespace’d elements.  It would look  like this:

var imageResults =
   // For each XML Element (ir) in the XML Document (doc.Descendants)
   from ir in doc.Descendants()
   // If the name is "ImageResult"
   where ir.Name.Equals("ImageResult")
   // Create a new ImageResult object
   select new ImageResult()
   {
      // Strings
      Title = ir.Element("Title").Value,
      MediaUrl = ir.Element("MediaUrl").Value,
      Url = ir.Element("Url").Value,
      DisplayUrl = ir.Element("DisplayUrl").Value,
      // Integers
      Width = Int32.Parse(ir.Element("Width").Value),
      Height = Int32.Parse(ir.Element("Height").Value),
      FileSize = Int32.Parse(ir.Element("FileSize").Value),
      Thumb = new ImageResult.Thumbnail()
   };

A Slightly Less Simple Query
Once we understand what the above simplified query does, let us layer another bit of complexity on top of it, adding back in the Thumbnail objects nested query.  The query then looks like this:

   // For each XML Element (ir) in the XML Document (doc.Descendants)
   from ir in doc.Descendants()
   // If the name is "ImageResult"
   where ir.Name.Equals("ImageResult")
   // Create a new ImageResult object
   select new ImageResult()
   {
      Title = ir.Element("Title").Value,
      MediaUrl = ir.Element("MediaUrl").Value,
      Url = ir.Element("Url").Value,
      DisplayUrl = ir.Element("DisplayUrl").Value,
      Width = Int32.Parse(ir.Element("Width").Value),
      Height = Int32.Parse(ir.Element("Height").Value),
      FileSize = Int32.Parse(ir.Element("FileSize").Value),
      Thumb =
          // for each XML element (th) in the XML element (ir)'s Descendants
         (from th in ir.Descendants()
          // If the name is "Thumbnail"
          where th.Name.Equals("Thumbnail")
          // Create a new ImageResult.Thumbnail
          select new ImageResult.Thumbnail()
          {
             Url = th.Element("Url").Value,
             ContentType = th.Element("ContentType").Value,
             Width = Int32.Parse(th.Element("Width").Value),
             Height = Int32.Parse(th.Element("Height").Value),
             FileSize = Int32.Parse(th.Element("FileSize").Value)
          }).Single(), // <-- Only one result for this sub-query
   };

The Full Monty Query

Got it? Good.  Finally we add back in the namespace information, and the query becomes slightly more verbose (though not necessarily more complex).

// Parse the XML response text
XDocument doc = XDocument.Parse(xml);

// Elements in the response all conform to this schema and have a namespace prefix of mms:
// For our LINQ query to work properly, we must use mmsNs + ElementName
XNamespace mmsNs = XNamespace.Get("http://schemas.microsoft.com/LiveSearch/2008/04/XML/multimedia");

// Build a LINQ query to parse the XML data into our custom ImageResult objects
var imageResults =
   from ir in doc.Descendants()
   where ir.Name.Equals(mmsNs + "ImageResult")
   select new ImageResult()
   {
      Title = ir.Element(mmsNs + "Title").Value,
      MediaUrl = ir.Element(mmsNs + "MediaUrl").Value,
      Url = ir.Element(mmsNs + "Url").Value,
      DisplayUrl = ir.Element(mmsNs + "DisplayUrl").Value,
      Width = Int32.Parse(ir.Element(mmsNs + "Width").Value),
      Height = Int32.Parse(ir.Element(mmsNs + "Height").Value),
      FileSize = Int32.Parse(ir.Element(mmsNs + "FileSize").Value),

      Thumb =
         (from th in ir.Descendants()
          where th.Name.Equals(mmsNs + "Thumbnail")
          select new ImageResult.Thumbnail()
          {
             Url = th.Element(mmsNs + "Url").Value,
             ContentType = th.Element(mmsNs + "ContentType").Value,
             Width = Int32.Parse(th.Element(mmsNs + "Width").Value),
             Height = Int32.Parse(th.Element(mmsNs + "Height").Value),
             FileSize = Int32.Parse(th.Element(mmsNs + "FileSize").Value)
          }).Single(),
   };

// Execute the LINQ query and stuff the results into our list
results = imageResults.ToList();

That does it for the requirements of this demo.  If anything in this post could use clarification, please let me know.

Silver Shorts : Get the Code on GitHub.com

If you have Silverlight installed, you can view the end result of my first experiment after the page break.  It is a simple Bing image searcher that displays thumbnails of the results on a canvas.

What is Project Silver Shorts?

More than anything Silver Shorts is an idea, a codename for a collection of demos in C#, most of which have yet to be written, targeting Silverlight 3, that are intended to be Short.  As I stumble and bumble my way around .NET, finding new and interesting things to do with it, I will make my experiments available with full source code on GitHub (skip to the bottom if all you care about is code.)

For the developers in the audience, let’s take a look at a simple LINQ query I have fabricated to summarize the goals of Silver Shorts while simultaneously showing off how neat LINQ is.

var blogPosts =
   from exp in user.Experiences()
   where exp.IsAwesome
   select new BlogPost()
   {
      Title = exp.Concept,
      Content = exp.Details,
      CodeUrl = exp.GitUrl;
   };

To be painfully and obnoxiously clear, this code example is not part of the actual demo program, it is only here to look pretty and be a conversation piece.

What is LINQ?

LINQ is a first class language extension that is available to any .NET language, and allows developers to treat their collections of objects and data as parts of an SQL-like query statement.  There are some resources that exlain LINQ decently well that I’ve managed to find.  I’ll go into more detail in future Silver Shorts about using LINQ to parse the above Bing Image search result XML into custom class data.

For now let us suffice to go over my LINQ query that tells you everything you need to know about Silver Shorts in less than 10 lines of code.

Step 1 – Identify the data sources

var blogPosts =
   from exp in user.Experiences()
   where exp.IsAwesome
   select new BlogPost()
   {
      Title = exp.Concept,
      Content = exp.Details,
      CodeUrl = exp.GitUrl;
   };

In this example we have a data source user.Experiences() which we’ll say is a collection of Experience objects.  Here we’re going to run a query against this data source and filter out only the experiences in which exp.IsAwesome is true.

Step 2 – Projections of the User experience objects into BlogPost objects

var blogPosts =
   from exp in user.Experiences()
   where exp.IsAwesome
   select new BlogPost()
   {
      Title = exp.Concept,
      Content = exp.Details,
      CodeUrl = exp.GitUrl;
   };

As the query executes, it finds objects that match the criteria we just mentioned, and from there our select statement will take the data from the Experience objects result and reformat it into a BlogPost.  For the purposes of our example, we’re assuming that we need to transform this data into a BlogPost object in order to be able to post it to a Wordpress Blog.

Step 3 – Execution and putting it all together

foreach( BlogPost bp in blogPosts )
{
   WordPress.post(bp);
}

An important thing to know about LINQ queries is that they are lazily executed.  That is to say, even though we have constructed our query statement above, it won’t actually do anything until we reference the data it is supposed to represent.   Generally speaking foreach loops are used to execute queries, but it is really whenever you reference your query “data” that it will be executed.

So in this foreach loop, the query is executed and the results are iterated across as BlogPost objects named (bp).

Booty

That just about does it for the inaugural post for Project Silver Shorts.   Next time we’ll go over the process of building the Image Search demo at the top of this post, including constructing a LINQ query to parse the XML results from the BING query, Asynchronous network access to perform the Query, and showing the results as thumbnail Images in a Grid.  Until then, enjoy your spoils.

Silver Shorts : Get the Code on GitHub.com

Confusing Love and Happiness

I take issue today with the institution of Valentines Day, which masquerades as a supporter of love, happiness, and all things good about personal relationships, concealing an insidious second purpose just beneath the surface.  VDay, with the help of our Advertising and Media, manages to juxtapose happiness and love for the purposes of making the argument that a persons happiness and fulfillment have a dependent relationship to love or, errm, relationships.

The Hidden Associations in VDay

To understand why I seem to loathe the existence of such a day we need only consider the long-held associations with it that reside silently in my mind.  To follow the somewhat chaotic jumping of logic below you must understand that the brain forms associations between all sorts of things and when you think about VDay it will look at memories from past relationships, heartbreaks, triumphs, failures, and anything remotely associated with your current feelings on VDay.

If you’ve ever been in a relationship during VDay your mind has not forgotten and will bring up the memories linked to relationships when you think about it, because it has formed an association between the two.  You can see then that if you’re in a relationship this year, likely thinking about VDay summons feelings of warmth and compassion, love, etc.  On the other hand if you’re single this year without a valentine, thinking about VDay may summon back unhappy memories from your collective pool of associated memories, perhaps a past VDay or relationship gone wrong.

The point here is that you, as a person, have an abundance of positive and negative associations already made up in your head for VDay, whether you know it or not.   Once you realize that, my argument that VDay sucks comes into focus.  Because within us all is the capacity to feel good or bad about VDay, the mere act of celebrating it suggests a good/bad relationship; you either have a valentine or you do not.

If noone is your Valentine on VDay, you are unloved

Once you’ve accepted my argument that associated past experience and memories are triggered when exposed to VDay’ish things, you need only look to the real world for examples of how knowledge of this can be exploited for financial gain.  Advertisers carefully craft their media to express to people very specific messages that support the argument that you NEED to participate or you don’t love your partner, or that you NEED to find a partner to participate with or you are not loved.

Defeating VDay’s Negative Associations

How can I defeat a day?   Well, I certainly can’t defeat February 14th as a calender day, I’ve tried that, it just comes back next year.    What I can do is choose to form new associations in mind with VDay.  In doing this, I can choose to respect the essence of VDay, which is the uplifting of love, without falling victim to it’s insidious consequences when viewed through a commercial lens.  What I mean by that is I have chosen today to be thankful for the love I have of knowledge.   The pursuit of more efficient ways to get things done, a deeper understanding of reality, a more complete understanding of my self; all these things I love to seek out, and this has been constant throughout my life.

So today I choose to show my love for knowledge and the pursuit of understanding, by associating this exercise in deconstructing my feelings on VDay with the day itself.

Singularly Triumphant

But why choose to associate writing this blog post with VDay?   Certainly it could be just by chance, but it has a particularly interesting feature in that associating this exercise with this day defines a sort of self-referencing association in that in this exercise I considered how I feel about this day, and in writing this blog I’ve put into words how I feel about this day.

Then again, perhaps “Gödel, Escher, Bach” actually is eating my brains.

Today let’s take a look at some of the amazing pictures it has returned.  All of the amazing detail of the images you see on this page are provided by HiRISE which is one of 6 instruments carried on-board the Mars Reconnaissance Orbiter…

Barchan Dunes in Chasma Boreale

High Resolution Imaging Science Experiment (link)

HiRISE is operated by the University of Arizona Tucson and has the most powerful telescopic camera ever flown to another planet at its disposal.  As of October 8th, 2009 the HiRISE project has released into the public domain almost 1.2million images, totaling just under 38Terabytes of data[3].

Sand Dunes

Dust Devils (wiki)

Another interesting thing to come out of HiRISE are pictures like you see below in which dust devils on the Martian surface leave dark trails in their wake.  It’s as if the dust devils are using Mars like a massive etch-a-sketch board.  If you click here, you can see a dust devil on the surface taken by one of the rovers.

Dust Devils

Near Surface Ice (blog)

There have been numerous pictures of Ice on the surface of mars, but recently people working at HiRISE have published findings that show evidence of ice being exposed and melting away just a few feet beneath the surface of the planet.   Not only that, but the locations of the craters having exposed ice are not in close proximity to the polar areas.

Exposed Ice from crater fades over time

You can read the full blog entry about it here.

Mars Reconnaissance Orbiter Details

For those studious readers out there, the MRO carries a payload of six instruments to help achieve it’s stated goals of gaining a better overall understanding of Mars in general, and identifying potential landing locations for future missions.

North Polar Layered Deposit and it's Ice Cap

High Resolution Imaging Science Experiment

Photographs the surface of mars in extreme detail.   It is expected to cover about 1 percent of the surface during it’s experiment lifetime.

Compact Reconnaissance Imaging Spectrometer for Mars

Provides spectral information to help identify patches of water-related minerals.

Context Camera

Takes wider-swath pictures to provide context for smaller images taken by other instruments.

Mars Climate Sounder

Tracks variations in water vapor, dust, and temperature in the atmosphere.

Mars Color Imager

Produces global images of Mars to track changes in the weather and ozone.

Shallow Subsurface Radar

Probes to approximately 1/3 of a mile below the martian surface to extract information about the layers of potential rock/ice/water that may be hidden.

—

Pretty cool stuff if you ask me.  If you’re not satisfied with the images presented here, feel free to go digging through the HiRISE website archive of images, but I’d definitely recommend starting with the Scientific Themes section of images.

—

References

1. NASA: Mars Reconnaissance Orbiter Mission Info – http://marsprogram.jpl.nasa.gov/missions/present/2005.html
2. NASA: Mars Exploration Program Historical Log – http://marsprogram.jpl.nasa.gov/missions/log/
3. HiRISE Blog: October 2009 PDS Release statistics – http://hirise.lpl.arizona.edu/HiBlog/2009/10/08/october-2009-pds-release/
4. HiRISE Blog: Water ice exposed! – http://hirise.lpl.arizona.edu/HiBlog/2009/09/25/water-ice-exposed/
5. NASA: Mars Reconnaissance Orbiter : Mission Fact Sheet – http://marsprogram.jpl.nasa.gov/mro/newsroom/factsheets/pdfs/MRO-060303.pdf

It’s not often that I feel compelled to write and about music, but every once in a while something stands out as being so worthy of praise that it would almost be a crime not to.   After months of listening and consideration, I believe that Yo-Yo Ma’s Appassionato is just one such thing.

In a collection of recordings spanning almost 3 decades, Ma has put together a fantastic story about his passion for music.  Each track guides you effortlessly into a new chapter, all magnificently decorated with the nuance and detail that you might expect from a well written book.  From the lighthearted introduction of “Going to School” by John Williams, to the provocative and enduring conclusion of “Gabriel’s Oboe” by Ennio Morricone; Ma’s careful selection of recordings tells the story of his love for music that my words cannot do justice.

You may preview all the tracks on Amazon’s page.  Share and enjoy.

In response to a blog post I wrote recently, a friend kindly pointed out that I seemed to have overlooked the work of Dr. Eric Kandel and others with respect to molecular changes that occur in neurons during learning.  In 2000 Eric Kandel was awarded the Nobel Prize along with Arvid Carlsson and Paul Greengard for their work detailing such molecular changes.  As it turns out because of their work, we actually have a pretty fantastic understanding about how things are committed to short and long-term memory, as well as the general way in which synaptic connections relate to the storage of things in memory.

Nobel Lecture 2000

My friend also provided a link to the lecture that Kandel gave while he was in Stockholm accepting the Nobel Prize.   I must admit that very little of the talk made complete sense to me, partly because the camera man chose not to show the screen while Kandel was using his laser pointer to go through the diagrams, and partly because I’m not a molecular biologist.   A few very cool insights did come out of watching the lecture, that are interesting enough to share…

Remembering Through Repetition

At one point or another in life you’ve probably run into someone that is keen on using repetition to help you remember things.   Be it a grade-school teacher or a parent trying to help you study for a test, this is a bit of common knowledge that has been around for years, and it would seem Kandel confirms that this is a legitimate way to commit things to long term memory.   In fact during his lecture he goes to great lengths to graph and show the effect repetition has on the length of time something is stored in memory for recall.   A single stimulation resulting in storage for just a few hours, while repeated stimulation (5 times) causes new protein synthesis, committal to long term memory, and recall for long periods of time.

Stronger vs New Synaptic Connections

Another interesting point Kandel and his fellows have brought to light is the distinction between what causes synaptic connections to strengthen, and what causes new synaptic connections to be formed.   In all of their testing cases, short-term memory storage involved only the modification of strength in existing synapses.   On the other hand, long-term memory storage has been associated with both modification of the strength of existing connections, as well as the formation of entirely new synaptic connections.  To be clear modification could mean strengthening or weakening of a synaptic connection.

CREB2 the bouncer

By far the most interesting thing to take away from this presentation was the process by which things are committed to long-term memory.   As I mentioned above, repetition seems to be the key factor in committing things to long term memory, but what’s more is that Kandel has figured out the reason for this.   In order for things to be committed to long-term memory, there needs to be new protein synthesis and part of new protein synthesis in a neuron requires activation of what is called the CREB1 transcription factor.   The catch is that CREB1 is repressed by another transcription factor called CREB2.   At this point you may have guessed that when you create the same stimulation in the neuron multiple times, eventually CREB2 let’s down its guard and CREB1 can be activated, which allows the process to continue and the memory to be committed to long-term storage.   Put in other words repeated stimulation acks like a secret handshake in the neuron that convinces CREB2 the bouncer to let in to the long-term memory storage party that’s happening just behind the door.  Kandel speculates that when there is a deficit in CREB2, this may be the reason behind certain individuals having photographic memories.  In fact they have observed this to be true in mice…

Oh but to be a mouse

In ending his lecture Kandel talked about some interesting thoughts about the clinical applicability of this research.   In particular he notes that as people tend to age, there are a number of disorders that affect their ability to convert short-term to long-term memory.   In experiments on mice Kandel and his team have been able to show that this is caused by a single defect that makes it difficult to initiate the transcriptional cascade process that was talked about earlier as being responsible for the storage of things into long-term memory.   By using their magic to overcome this deficit, they have been able to produce flash-bulb memory in mice.   As Kandel himself jests.. “So if you’re a mouse, we can really help you with age-related memory loss”

While we may not be to a point that we can come up with a convenient little pill to help us convert things to long-term memory storage, the idea that it is possible in the future is quite appealing.