Philip Lippard

Please say it ain't so

Photoshop Containers for Dummies

One common practice in web site design is the use of visual containers.   Containers can take the form of rounded corner containers, shadowed containers and many other variations.   There are also many techniques for simplifying the implementation of containers.  There are many JavaScript based solutions for rounding corners or for expressing a shadow, however the JavaScript solutions are never as visually effective as containers based on a layered Photoshop design.  The Photoshop slice tool is used to cut the needed elements (as small as possible) to be used within a layered DIV container approach, along with cascading style sheet (CSS) styling.  The Photoshop slice tool is used to cut the top header row left and right corners and then a 1 pixel wide element to be repeated between the left and right corners to form a complete header row.  The slice tool is then used to cut the same elements for the bottom footer row, and lastly the slice tool is used to cut the variable height content section left and right edges and 1 pixel wide inner content background.

Using the Photoshop slice tool cannot be avoided, however the ASP.NET implementation can be greatly simplified for repeated container implementations.  The focus of this article is to show how a custom server control can be written and used to programmatically generate variable width and height containers such that the DIV layering complexity is completely abstracted away within the server control.

To illustrate, the following sample web page contains one such custom server control:

   1:  <body>
   2:      <form id="form1" runat="server">
   3:      <div>
   4:          <socrates:InjectContainer ID="test" runat="server">
   5:              <ContentTemplate>
   6:                  <br />
   7:                  <br />
   8:                  <asp:Button ID="btnStart" runat="server" Text="Start" 
   9:                      OnClick="btnStart_Click" />
  10:                  <br />
  11:                  <asp:Label ID="lblStatus" runat="server" />
  12:                  <br />
  13:              </ContentTemplate>
  14:          </socrates:InjectContainer>
  15:      </div>
  16:      </form>
  17:  </body>

 

The ContentTemplate contains a combination of HTML and ASP.NET server controls; in this case a very simple button and status line to display Hello World when the button is depressed, as rendered below:

Image-0001

 

The InjectContainer control will enclose the content within the ContentTemplate template with the various DIV layers necessary to achieve an effective cross browser container implementation.  The Container size is NOT limited in any respects, fully controlled by the cascading style sheet.  In the above example the following HTML is generated and injected into the web page.

   1:  <div id="test">
   2:      <div class="Header">
   3:          <div class="HeaderLeft">
   4:              <div class="HeaderRight">
   5:                  <div class="HeaderContent">
   6:                  </div>
   7:              </div>
   8:          </div>
   9:      </div>
  10:      <div class="Body">
  11:          <div class="BodyLeft">
  12:              <div class="BodyRight">
  13:                  <div class="BodyContent">
  14:                      <br />
  15:                      <br />
  16:                      <input type="submit" 
  17:                          name="test$ctl08$btnStart" 
  18:                          value="Start"    
  19:                          id="test_ctl08_btnStart" />
  20:                      <br />
  21:                      <span id="test_ctl08_lblStatus"></span>
  22:                      <br />
  23:                  </div>
  24:              </div>
  25:          </div>
  26:      </div>
  27:      <div class="Footer">
  28:          <div class="FooterLeft">
  29:              <div class="FooterRight">
  30:                  <div class="FooterContent">
  31:                  </div>
  32:              </div>
  33:          </div>
  34:      </div>
  35:      </div>
  36:  </div>

As you can see, most of the generated HTML are the layers of DIV sections; necessary to achieve the visually effective container.  Most of the heavy lifting is done by the InjectContainer custom server control, as well as the CSS style sheet, shown below:

   1:     <style type="text/css">
   2:          
   3:          body
   4:          {
   5:              background-color: Beige;
   6:              margin-top: 100px;
   7:              margin-left: 100px;
   8:          }
   9:          
  10:          #test
  11:          {
  12:              width: 310px;
  13:          }
  14:          
  15:          #test .Header
  16:          {
  17:          }
  18:      
  19:          #test .HeaderLeft 
  20:          {
  21:              padding-left: 2px;
  22:              height: 3px;
  23:              background-image: url(/Images/Containers/White-Block/HeaderLeftEdge.png);
  24:              background-repeat: no-repeat;
  25:              background-position: top left;
  26:          }
  27:          
  28:          #test .HeaderContent
  29:          {
  30:              height: 3px;
  31:              background-image: url(/Images/Containers/White-Block/HeaderContent.png);
  32:              background-repeat: repeat-x;
  33:              background-position: top left;
  34:          }
  35:          
  36:          #test .HeaderRight
  37:          {
  38:              padding-right: 8px;
  39:              height: 3px;
  40:              background-image: url(/Images/Containers/White-Block/HeaderRightEdge.png);
  41:              background-repeat: no-repeat;
  42:              background-position: top right;
  43:          }
  44:          
  45:          #test .Body
  46:          {
  47:          }
  48:          
  49:          #test .BodyLeft 
  50:          {
  51:              padding-left: 2px;
  52:              height: 200px;
  53:              background-image: url(/Images/Containers/White-Block/BodyLeftEdge.png);
  54:              background-repeat: repeat-y;
  55:              background-position: top left;
  56:          }
  57:          
  58:          #test .BodyContent
  59:          {
  60:              height: 200px;
  61:              background-image: url(/Images/Containers/White-Block/BodyContent.png);
  62:              background-repeat: repeat;
  63:              background-position: top left;            
  64:              text-align: center;
  65:          }
  66:          
  67:          #test .BodyRight
  68:          {
  69:              padding-right: 8px;
  70:              height: 200px;
  71:              background-image: url(/Images/Containers/White-Block/BodyRightEdge.png);
  72:              background-repeat: repeat-y;
  73:              background-position: top right;
  74:          }
  75:          
  76:          #test .Footer
  77:          {
  78:          }
  79:          
  80:          #test .FooterLeft 
  81:          {
  82:              padding-left: 2px;
  83:              height: 9px;
  84:              background-image: url(/Images/Containers/White-Block/FooterLeftEdge.png);
  85:              background-repeat: no-repeat;
  86:              background-position: top left;
  87:          }
  88:          
  89:          #test .FooterContent
  90:          {
  91:              height: 9px;
  92:              background-image: url(/Images/Containers/White-Block/FooterContent.png);
  93:              background-repeat: repeat-x;
  94:              background-position: top left;
  95:          }
  96:          
  97:          #test .FooterRight
  98:          {
  99:              padding-right: 8px;
 100:              height: 9px;
 101:              background-image: url(/Images/Containers/White-Block/FooterRightEdge.png);
 102:              background-repeat: no-repeat;
 103:              background-position: top right;
 104:          }
 105:      
 106:      </style>

The InjectContainer control can also be used in a nested manner to generate a different container within a container, provided of course the ID= attribute is different for each InjectContainer instance so each container can be uniquely styled within its companion cascading style sheet.

The C# source code for the InjectContainer custom server control is as follows:

   1:  using System;
   2:  using System.ComponentModel;
   3:  using System.Text;
   4:  using System.IO;
   5:  using System.Web;
   6:  using System.Web.UI;
   7:  using System.Web.UI.WebControls;
   8:  using System.Web.UI.HtmlControls;
   9:  using System.Drawing;
  10:  using System.Resources;
  11:   
  12:  namespace Socrates.CustomControls.Containers
  13:  {
  14:      public class MyTemplateContainer : Control, INamingContainer
  15:      {
  16:          /// <summary>
  17:          /// MyTemplateContainer.
  18:          /// </summary>
  19:          public MyTemplateContainer()
  20:          {
  21:          }
  22:      }
  23:   
  24:      [
  25:          ToolboxData("<{0}:InjectContainer runat=server></{0}:InjectContainer>"),
  26:          ParseChildren(true),
  27:          PersistChildren(true)
  28:      ]
  29:      public class InjectContainer : CompositeControl
  30:      {
  31:          private ITemplate m_ContentTemplate = null;
  32:   
  33:          private Control RenderHeader()
  34:          {
  35:              return RenderBlock("Header", null);
  36:          }
  37:   
  38:          private Control RenderBody(MyTemplateContainer i)
  39:          {
  40:              return RenderBlock("Body", i);
  41:          }
  42:   
  43:          private Control RenderFooter()
  44:          {
  45:              return RenderBlock("Footer", null);
  46:          }
  47:   
  48:          private Control RenderBlock(string BlockName, 
  49:              MyTemplateContainer i)
  50:          {
  51:              HtmlGenericControl divContainer = new HtmlGenericControl("div");
  52:              divContainer.Attributes.Add("class", BlockName);
  53:              HtmlGenericControl divLeft = new HtmlGenericControl("div");
  54:              divLeft.Attributes.Add("class", BlockName + "Left");
  55:              HtmlGenericControl divContent = new HtmlGenericControl("div");
  56:              divContent.Attributes.Add("class", BlockName + "Content");
  57:              HtmlGenericControl divRight = new HtmlGenericControl("div");
  58:              divRight.Attributes.Add("class", BlockName + "Right");
  59:   
  60:              if (i != null)
  61:              {
  62:                  divContent.Controls.Add(i);
  63:              }
  64:   
  65:              divRight.Controls.Add(divContent);
  66:              divLeft.Controls.Add(divRight);
  67:              divContainer.Controls.Add(divLeft);
  68:   
  69:              return divContainer;
  70:          }
  71:   
  72:          protected override HtmlTextWriterTag TagKey
  73:          {
  74:              get
  75:              {
  76:                  return HtmlTextWriterTag.Div;
  77:              }
  78:          }
  79:   
  80:          protected override void CreateChildControls()
  81:          {
  82:              Controls.Clear();
  83:   
  84:              if (ContainerClass.Length > 0)
  85:              {
  86:                  if (base.Attributes["class"] == null)
  87:                  {
  88:                      base.Attributes.Add("class", ContainerClass);
  89:                  }
  90:              }
  91:   
  92:              base.Controls.Add(RenderHeader());
  93:   
  94:              if (ContentTemplate != null)
  95:              {
  96:                  MyTemplateContainer i = new MyTemplateContainer();
  97:                  ContentTemplate.InstantiateIn(i);
  98:                  base.Controls.Add(RenderBody(i));
  99:              }
 100:              else
 101:              {
 102:                  base.Controls.Add(RenderBody(null));
 103:              }
 104:   
 105:              base.Controls.Add(RenderFooter());
 106:          }
 107:   
 108:          [
 109:              PersistenceMode(PersistenceMode.InnerProperty),
 110:              TemplateContainer(typeof(MyTemplateContainer))
 111:          ]
 112:          public ITemplate ContentTemplate
 113:          {
 114:              get
 115:              {
 116:                  return m_ContentTemplate;
 117:              }
 118:              set
 119:              {
 120:                  m_ContentTemplate = value;
 121:              }
 122:          }
 123:   
 124:          public string ContainerClass
 125:          {
 126:              get
 127:              {
 128:                  return (this.ViewState["_ContainerClass"] == null) ? "" : (string)this.ViewState["_ContainerClass"];
 129:              }
 130:              set
 131:              {
 132:                  this.ViewState["_ContainerClass"] = value;
 133:              }
 134:          }
 135:      }
 136:  }

If you have any questions, please feel free to send me an email.

Monotouch - Worth an Evaluation

MonoTouchBoxPersonal There are a number of third party offerings which provide a iPhone look and feel for the Microsoft development environment.  Such alternatives usually require that any deployment must run within the iPhone based Safari browser.  Unlike these third party offerings, Novell (a name from the past) is offering a product named Monotouch, which runs on a Mac along with the iPhone Development SDK (Cocoa Touch, Objective C, etc) and Monotouch wraps the iPhone framework APIs such that .Net C# can be used as the development language.  The Monotouch user must continue to be a member of the iPhone Development Program.

Not sure if all the effort of learning all the restrictions of interfacing .Net and C# as an iPhone Development SDK wrapper would be worth the effort, but clearly it is worth consideration.  After careful study it may be that the only reason for considering Monotouch would be for those in the Development community who are simply opposed to learning Objective C.

More Problems for Windows Mobile

With all the positive visibility for the iPhone and the open-source Android OS, Windows Mobile from Microsoft continues to loose market share.  Only 7.9 percent of smart phones sold last quarter were equipped with Windows Mobile, down from 11.1 percent during the same period last year. According to the report, 3.2 million devices were Windows Mobile-based, compared with 4 million last year.  Read the entire article...

Every Man Deserves To Have His Play Toys

My play toy just happens to be 8GB of memory.

8GB Installed on Thinkpad T61p My 8GB of Kingston memory arrived today for my Thinkpad T61p (two 4GB cards).  I did realize a performance gain, and over the next few days I will assess whether multiple concurrent virtual machines perform faster and smoother.  As you can see in the left-most image, my T61p now has 8GB installed with a Windows 7 64 bit host OS.

Windows 7 64 Bit Host Performance After Kingston Memory Installation As far as a performance gain, the right-most AFTER image shows the improved performance using the Windows 7 performance metrics. 
Windows 7 64 Bit Host Performance Before Kingston Memory Installation The right-most BEFORE image shows comparable performance before the Kingston memory installation.
As you may recall from my original Sep-2009 blog post I have pursued several steps in getting ready for 64 bit Windows 7 and also extending the life of and improving the performance of my Thinkpad T61p.  My principal objective has been to migrate my host OS and eventually all guest OSs to 64 bit, however in doing so I also wanted to speed up the hard drives while also adding additional memory to assist with the 64 bit host OS improved performance.  To summarize the steps taken since Sep-2009:
 
  • Replace original T61p hard drives with faster Hitachi drives; both primary and Ultra-Bay drive.  All VMs are on Ultra-Bay drive.
  • Consider which virtual machine management software I want to use with Windows 7 64 bit host OS.  After a few problems, I realized that Microsoft had taken a significant step backwards with the Windows 7 version of Windows Virtual PC (WVP) support and I settled on using the new Windows 7 compatible version of VMWare Workstation; version 7.0. My biggest problem with VMWare Workstation was a problem in conducting an iPhone synchronization within a VMWare virtual machine; which ultimately was resolved as an iPhone data corruption problem.
  • Replace my existing 4GB of memory with 8GB of faster Kingston memory.  The obvious goal here was to provide memory beyond the 4GB limit for 32 bit OSs, so that Windows 7 64 bit can freely use all addressable memory, thus hopefully realizing faster and smoother virtual machine performance.

 

Four VMs on Windows 7 64 Bit Host With the above steps now completely realized, here is a sampling of the end result; four concurrent executing virtual machines.....from left to right....1) My old Vista 32 bit Development VM, now converted from VPC 2007 to a VMWare VMDK VM...2) My new 64 bit Windows 7 Development VM; loaded with VS.NET 2010 Beta 2 and all the newly announced products from PDC Nov-2009....3) My 32 bit Windows 7 Administrative VM; containing Outlook, Quicken, etc....and lastly... 4) A small Windows XP image containing IE6 and Firefox 1.5, which I use for legacy testing.  The 1st three VMs are assigned 2GB of memory each, while the Windows XP VM is assigned 256MB.   Of course, the host OS is 64 bit Windows 7.   Sure beats the COMPAQ arm stretcher portable I used to carry through airports in the mid to late 1980s.

Now....is this cool or what ?

iPhone Backup/Syncing VMWare Issue Resolved

iPhone Corruption After moving to VMWare Workstation 7.0 using Windows 7 64 bit as the host OS, the one remaining problem I had was the inability to backup/sync my iPhone in a VMDK virtual machine.  After opening a problem with VMWare and spending many hours testing various tests with VMWare the problem has resolved to being a problem with the iPhone firmware.  It appears that a corruption problem can occur when moving the iPhone firmware from version 2 to version 3.  The symptom of the problem is extreme slowness when backing up one's iPhone.

For me, the extreme slowness in backing up/syncing the iPhone showed up as the complete inability to backup/sync my iPhone within a VMDK virtual machine.  The iPhone backup/sync would come to a complete halt for some reason.

To resolve the iPhone corruption problem, I removed all of my free iPhone applications, which number 20-30 such applications (I am too cheap to actually purchase many iPhone apps).   I then conduct a hard reset on the iPhone, after which I reinstall all of the 20-30 applications.  At this point, my iPhone backup runs in only about 5 minutes, which was taking over 2 hours with the iPhone corruption problem.

Working with VMWare on this problem was frustrating at times, however they did provide excellent support, even though the problem is with the iPhone.

Using VMWare for my virtual machine support along with a Windows 7 64 bit host OS has been an excellent combination.

My 8gb is on the way via UPS from California.  As you know from my prior blog posts the 8gb is part of the master plan in moving to a 64 bit host OS.   I should see some improved performance, especially when executing multiple concurrent virtual machines.

Facebook Integration with MSFT Facebook SDK

Facebook Development I gave a presentation last night on Facebook Integration using the Facebook Developer's Toolkit (FDT).  FDT is available on CodePlex and effective with FDT release 3.0 has been renamed to the Microsoft Facebook SDK.   Click HERE to download my Power Point presentation and sample C# projects from last night's event.

Facebook offers several ways to implement Facebook applications.   When integrated within the context of the Facebook web site, such applications are referred to as Facebook Canvas applications.  Canvas application take on two major flavors; IFrame constructed applications and Facebook Markup Language (FBML) applications.  External web sites can also enable Facebook users to use their Facebook login IDs within respective external web sites, referred to as the Facebook Connect feature.  Windows desktop applications can also be written to benefit from Facebook and gain access to Facebook data, either as Windows Winforms or WPF applications.

The Microsoft Facebook SDK wraps the Facebook REST API to simplify and facilitate ease of development of each of the above application/ deployment types.

Download the Power Point and code from the 1st paragraph to learn more.

Virtualization Performance Results

-I have continued to test the following Windows 7 configuration. 

  • Windows 7 64 Bit Host OS…with either Windows 7 Virtual PC (WVPC) RC support ....or VMWare 6.5 Workstation ...(both are NOT installed at same time)
  • Vista 32 Bit Guest OS (VM # 1 )
  • Windows 7 32 Bit Guest OS (VM # 2)

I was advised by MSFT support that for best overall Windows 7 virtualization performance I should disable the BIOS Speedstep setting in my BIOS Power settings.  These performance results reflect this BIOS Speedstep setting being disabled.

Performance results when comparing WVPC RC to VMWare are as follows…

  1. With only VM # 1 active ... opening a web site project...WVPC takes 1 min 0 sec... VMWare takes 0 min 25 sec.
  2. With only VM # 1 active.... a build of one of my typical web sites ... WVPC takes 3 min 42 sec....VMWare takes 2 min 10 sec.
  3. With both VM # 1 and VM # 2 active... a build of the same web site ... WVPC takes 7 min 20 sec....VMWare takes 4 min 26 sec.

I find that boot-up time is roughly the same for both WVPC and VMWare.... regardless of number of VMs active....obviously boot-up time for two VMs at the same time takes longer....however WVPC takes roughly the same time as VMWare.

vmwareConsidering the above performance results …I have decided to use VMWare for virtualization support as I migrate to Windows 7.  The following VMWare features are also quite compelling:

  • Much better device support…reassignment of devices, etc.
  • Ability to record and replay as a video of a VM's operations.
  • Ability to suspend or take a snapshot of a VM….and resume execution.
  • Richness of configuration options…such as number of CPUs to use within a VM.
  • Ability to host 64 Bit guests OSs.

Next step…I upgrade my Thinkpad T61p memory to 8gb....and over time I migrate the virtual machines from 32 bit to 64 bit.

Backing Off to Windows Vista 64 Bit

Vista 64 Bit Performance Given the problems encountered with Windows Virtual PC (WVP) support, rather than backing off to my Vista 32 Bit host OS, I have decided to back-off to a Vista 64 Bit host OS.  This will enable me to realize the memory relief I am looking for when executing concurrent virtual PCs.

Windows Vista 64 Bit does not provide the performance rating as Windows 7 but it will have to do for now.  I am ordering my 8gb of memory today.


Hitachi SATA 3.0gb Interface Drive Performance I found a utility on the Internet called CrystalDiskMarkwhich provides meaningful disk performance statistics.  My new Hitachi SATA 3.0gb interface Thinkpad T61p hard drives provide a noticeable performance improvement when compared to the performance of the 5400RPM drives I had been using. 

T61p-5400RPM-Disk-Performance I had been using the slower 5400RPM drives primarily because it was what was available at the time (2007) for larger capacity drives.


Biggest drawback with not having Windows 7 64 bit as my host OS is that Windows 7 Virtual PCs support attaching a USB device to a VPC....however I am unable to do so with Vista 64 bit and the predecessor VPC 2007 product......so I am NOT able to sync-up my iPhone within a Vista 64 bit VPC.....and of course Outlook must be in the same VPC for the sync-up.

Windows 7 64 bit - Extending Thinkpad T61p life and improving performance

windows7rc_bloglogo_thumb

As we approach the official release date of Windows 7, I have been considering how I can extend the life of and improve the performance of my Thinkpad T61p (Intel Core 2 Duo CPU T7800 @ 2.60 Ghz) which I purchased in Nov-2007 (pre-crash).  I have been considering using Windows 7 64 bit as my host OS and executing practically everything else in Windows Virtual PCs.  I have been a heavy user of Virtual PC (VPC) 2007 and its predecessor VPC 2004 product, however up to now I have limited my VPC use to development tools only.  My development VPCs include the following:

 

  • Vista/ VS.NET 2008 development environment
  • Windows XP/ VS.NET 2005 development environment
  • Windows XP/ VS.NET 2003 development environment
  • SQL Server 2005 - Enterprise test environment
  • Windows Server 2003 test environment
  • Windows Server 2008 test environment
  • Windows XP DotNetNuke test environment
  • Windows XP IE6 and Firefox 1.5 legacy test environment
  • Windows XP IE7 legacy test environment

I also use what I refer to as my Day-to-Day applications heavily on the same Thinkpad (word processing, online banking, email, iTunes, archive, everything except development).  I also want to consider pushing these Day-to-Day applications down into a dedicated VPC.  One primary reason for this is security; when the Thinkpad needs to be serviced, which involves sending the unit off to IBM Memphis for depot maintenance.  Having Day-to-Day applications as well as development tools in VPCs makes it easy to send a skinny hard drive to IBM Memphis; eliminating the worry of whether my data will be compromised.  I have owned six or seven Thinkpads since 1992, and I usually have to send a unit to IBM Memphis at least once during a three year warranty period.

safe_image

As a result of the inherit benefits of using a 64 bit OS versus 32 bit, a performance gain will no doubt be realized.  I also want to upgrade the hard drives to units which support a Serial ATA 3.0gb interface versus the current 1.5gb interface.  I considered some of the new solid state drives, however capacity is not what I need (usually caps out at around 128gb) and costs is prohibited at around $750 per 128gb drive.  On the other hand, the performance of traditional SATA hard drives have improved significantly.  Hitachi drives are available with a capacity of 320gb for less than $100 (a raw 2.5 SATA drive; no chassis; click on hard drive image).

 

Lenovo-ThinkPad-T61p

My T61p currently has 4gb of memory (two 2gb memory cards).  Because of the 64 bit host OS, I want to consider getting two 4gb memory cards; thus providing total memory of 8gb for heavy VPC usage.   As a result of 64 bit CPU operations, I expect a performance improvement with the 64 bit OS alone, however the real benefit I am looking for from a 64 bit OS is the broader range of memory available.  With 32 bit, memory access is limited to 4gb total.  With 64 bit, I expect the 8gb memory to provide quite noticeable multiple VPC performance improvements. Click the Thinkpad image to see memory I am considering.

 

32-Bit-Performance

Before I embark on installing my Windows 7 64 bit host OS onto my new Hitachi drive, I first want to obtain performance measurements of my current Vista 32 bit environment.  I go to Control Panel/ Performance Information and Tools, where one can request a performance rating.  One should note from this 32 bit performance rating that 1) Processor calculations per second is rated @ 5.4.......2) Memory operations per second is rated @ 5.1.....and 3) Primary hard drive transfer data rate is rated @ 5.1.

The installation of Windows 7 64 bit proceeded without incident, with the exception of the need for a nVidia 64 bit graphics interface driver, which I located on the Internet.  Virtual PC support within Windows 7 has changed names to Windows Virtual PC (WVP).  WVP is available via a separate download, in release candidate form as of this writing.

VPC-Hardware-Virtualization Before switching over to a Windows 7 64 bit host OS, I fully prepare my VPCs for the switchover.  I create the Day-to-Day VPC containing all of my non-development related applications and I use Windows 7 32 bit as the guest OS for this Day-to-Day VPC.  Immediately before the switchover I plan to start with two primary VPCs; my Vista 32 bit VS.Net 2008 Development VPC and my new Windows 7 32 bit Day-to-Day VPC.  Both are executing great with a Vista 32 bit host OS and Virtual PC 2007.  BTW...I did notice that VPC 2007 now has a Hardware Virtualization option; thus providing improved performance when one enables BIOS level Hardware Virtualization.  I am not sure when this Hardware Virtualization option surfaced in the VPC 2007 product.  As I move forward to a Windows 7 64 bit host OS and WVP, I am surprised that Microsoft requires BIOS level Hardware Virtualization if one plans on executing virtual machines un Windows 7.  I have read on the Internet that if one does not have a CPU with the Hardware Virtualization feature that VPC 2007 can be installed on Windows 7, however it is NOT a supported environment.  Considering the completeness of Windows 7, this restriction is surprising.

64-Bit-PerformanceEverything is set to go; Windows 7 64 bit host OS is installed on faster Hitachi hard drive, however I have not yet purchased the 8gb of memory.  The 8gb of memory is primarily beneficial for multiple VPC performance, so I want to make sure everything works well first before making this investment.  I conduct a performance rating of the Windows 7 64 bit host OS and see these results.  Note the improved performance of  1) Processor, 2) Memory ...and 3) Primary Hard Drive, providing an overall performance rating of 5.8.

My general observations from copying quite large data files (VPCs) back and forth from backup USB devices is that that the Hitachi 3gb interface SATA drive appears to be about 40% faster than the 1.5gb SATA drives.

Regrettably, as I move forward to implementing the VPCs within Windows 7 WVP, I first install the new WVP Integration Components (the equivalent of VPC 2007 Virtual Machine Additions) and my WVPs work well for awhile, however after a short while the WVPs start consuming 100% CPU time for no obvious reason.  I actually spent four days working on this and I always encounter the same problem of the WVPs consuming 100% CPU time.   As a result, I can only conclude that the WVP release candidate is not ready for prime time.  For now, I am moving forward to replacing my drives with the faster Hitachi 3.0gb SATA drives (I have a primary and a secondary - VPCs on secondary drive), however regrettably my host OS will continue to be Vista 32 bit for now.  My VPCs are prepped and ready for the move to a Windows 7 64 bit host OS whenever I can find the time to work with MSFT to get the WVP problem resolved.  So, Windows 7 looks great and I am ready to purchase the 8gb of memory, however Windows Virtual PC (WVP) support does not look so good.... at least for now.

I have also noted that Norton Ghost version 14.0 is not supported in Windows 7.  I am not sure I want to move forward with a Windows 7 64 bit host OS if I have no means to take image copies of my drives.  I will have to assess who owns Norton Ghost at this point (Symantec I think) and see if a new version is forthcoming.

So, at this point the show stoppers for moving forward to a Windows 7 64 bit host OS is questionable Windows Virtual PC (WVP) support and Windows 7 compatible Norton Ghost support.

Airline Baggage Charges

We are no doubt in an age of airline charges for just about anything that one can imagine; baggage fees for checked baggage, even higher fees for one's 2nd or 3rd checked bag.  I know this all too well because I am a part-owner in an Internet shipping business; called ShipMyLuggage.net, and in fact the ShipMyluggage.net start-up was justified in part due to the treatment consumers are receiving from the airlines.  I think well known Southwest Florida cartoonist Dave Horton illustrates it best in this cartoon below...

Bag Charges