Windows 8 Consumer Preview on Lenovo S10-3T

Posted in Windows 8

With the announcement of the 2nd release of Windows 8 “The Consumer preview edition” back in February I thought it would be a good time to finally crack it open and take a look.  I’m interested from several different perspectives:

  • Is this thing even usable as a tablet and subsequently as a desktop.
  • How consumer and corporation friendly is it.
  • How polished is it in it’s current state (perhaps inferring some relative release timeframe).
  • Is Html5/JavaScript app development done in such a way that it’s likely to catch on the way Microsoft expects.

To start with though, I need to get Windows 8 installed somewhere and that’s what this post is all about.  Luckily enough I’ve had a Lenovo S10-3T netbook for a little while now and it generally acts as a living room/kitchen browsing machine.  In other words, the perfect machine to cannibalize!  Windows 8 will install onto the S10-3T with a little elbow grease. To get started, let’s take a look at the installation requirements of Windows 8 and the hardware specs for the S10-3T.


S10-3T Specs:

Processor Intel Atom 1.66GHz N450
Ram 2GB DDR2
Hard drive 320GB 6400RPM SATA
Wi-Fi 802.11b/g/n
Screen type Multi Touch Touch Screen - Swivel and Rotatable
Screen size 10.1
Resolution 1024 × 600

Note:  The Lenovo S10-3T  had several flavors of hardware, so your S10-3T may not necessarily have the same specs.

Windows 8 Consumer Preview’s Minimum System Requirements

From Windows 8 Consumer Preview: Frequently asked questions

Processor 1GHz or faster 32 Bit or 64 Bit
Ram 1GB for 32 Bit and 2GB for 64 Bit
Hard disk space 16GB Available hard disk Space for 32 Bit and 20 GB Available Hard Disk Space for 64 Bit PC's
Graphics card DirectX 9 Graphics Device with WDDM 1.0 or higher driver.
Resolution ???

Additional requirements to use certain features:

  • To use touch, you need a tablet or a monitor that supports multitouch.
  • To access the Windows Store and to download and run apps, you need an active Internet connection and a screen resolution of at least 1024 x 768.
  • To snap apps, you need a screen resolution of at least 1366 x 768.

Resolution Issue

Initially this looks to be a pretty grim issue.  The S10-3T only has a max resolution of (1024 x 600) and the minimal resolution “To access the Windows Store and to download and run apps” is 1024 x 768.  Oddly enough Windows 8 will let you install on lower resolutions (perhaps this’ll be changed by release), however I can’t imagine the experience being all that spectacular without being able to download and run apps.

Searching the internet for workarounds reveals a handful of people already having installed Windows 8 on the S10-3T (albeit the previous preview) using a registry hack to enable higher resolutions via down scaling (more specifically 1024 x 768 and 1152 x 864).  See liliputing.com and lenovos103t.com/jessebandersen.com for more information. But what is down scaling actually doing?

In numerical modeling, downscaling refers to techniques that take output from the model and add information at scales smaller than the grid spacing

Quoted from: http://en.wikipedia.org/wiki/Downscaling

In other words we still only have 600 physical pixels, we’re just jamming 768/864 worth of pixel data into 600 pixels of space and hoping for the best.  Display properties will show the increased resolution of 1024 x 768 and 1152 x 864, but under the covers the operating system will down scale that to 600 pixels.  The other downside is that the aspect ratios are slightly different, so the display is going to look somewhat stretched horizontally. All in all this isn’t a perfect solution, however it’s the only solution.  Additionally looking at some screen shots online was reassuring enough in that the horizontal stretch isn’t unreasonable.  If it’s between down scaling or no apps, I’ll take the down scaling.

Note: I’ll get into the exact details of how to do this during implementation.

32 Bit or 64 Bit

With the Windows 8 Consumer Preview we have the choice of pulling down either the 32 bit version or the 64 bit version.  Additionally the S10-3T’s hardware is 64 bit compatible.  After a little bit research it looks like 32 bit is the clear winner in this case.

There are very few advantages to 64 bit for the S10-3T.  64 bit windows programs actually take a little extra RAM because their memory pointers are a little bit bigger.  Therefore even at Idle the 64 bit system is taking more RAM memory.

RAM usage with 32 bit OS at idle: about 480MB

RAM usage with 64 bit OS at idle: about 650MB

Also you have to remember that now the OS will try to run compatibility programs and therefore more processes which will slow your CPU and take RAM space.

2GB is not a large amount of RAM and you are better of with the 32 bit os.  If you have 4GB RAM in a system then 64 bit seems like a better idea.

Quoted from: http://www.lenovos103t.com/2010/03/32-bit-vs-64-bit-windows-7-on-s10-3t.html

A Good Time for a Backup

I really had nothing important on my S10-3T, however I still created a full backup in just in case something did go horribly wrong.  Depending on your situation you may not need this step at all or may need to just backup a handful of files. Regardless, I have a license for Acronis True Image and just used that to do a quick backup over the network.  The pricing is good and the product works, good enough in my book.  Only needed 20GB of space, which transferred over the LAN at a reasonable pace.

Warning Before Installation

After installation the WIFI was in the “off” state (as if it had been turned off via the fn key) and the necessary driver for fn key functionality is Lenovo specific and not part of Windows 8 Consumer Preview.  In my case I just plugged in an Ethernet cable and downloaded the necessary drivers.  You may want to download the drivers to a usb key first before continuing with installation if you’re only on WIFI. See the drivers section for more information.

Web Installer or ISO

The Web Installer option is probably the easiest option to use for installation, since the S10-3T doesn’t have a DVD drive, if you used the Web Installer skip to the next section. 

In my case I started out looking for the ISO and didn’t even realize there was an installer until afterwards.  If you do go the ISO route, then you will need an external USB DVD drive.  I happened to have one lying around collecting dust so this option worked out pretty good.

Web Installer Download: http://windows.microsoft.com/en-US/windows-8/download
ISO Download: http://windows.microsoft.com/en-US/windows-8/iso

Burn the ISO to DVD using “Windows Disc Image Burner”, which should be in the Context Menu in Windows 7, unless you have another ISO burning program installed in which case you need to select “Open With” and then select “Windows Disc Image Burner”.

Next up, hook up a USB DVD and boot from the DVD.  For some reason the S10-3T refused to boot from the DVD even with the boot order updated correctly to have the DVD before the hard drive.  I removed everything else (besides the DVD) from the bootable options and this forced it to boot from the DVD. 

Once booted in to the installation DVD let it work it’s magic.  If you opted for the DVD/ISO install you need this product key during installation: NF32V-Q9P3W-7DR7Y-JGWRW-JFCK8 as detailed on the Windows 8 Consumer Preview: Frequently asked questions page. 

After the first reboot make sure to set your boot options back to normal in the bios.

A Couple of Reboots Later

Windows 8 Consumer Preview should be installed after a couple of reboots. Go ahead and do all of the initial configuration and log in. Notice that Windows 8 appears to be working relatively fine despite our low resolution (the true minimum resolution must be less than 1024 x 600).  Note: I had already logged in and customized a few things by the time this screen shot was taken so you’re Start screen may look slightly different.


Increasing the Resolution

Now that we have Windows 8 running it’s time to tackle the resolution issue.  Per the Minimum System Requirements “To access the Windows Store and to download and run apps, you need an active Internet connection and a screen resolution of at least 1024 x 768. ”  and we certainly want to download and run apps otherwise running the preview wouldn’t be very interesting or useful.

  1. Swipe from right to left towards the right edge of the screen and select the Search icon in the upper right.
  2. Type “regedit” into the “Search  Apps” box and then start regedit.

  3. Search for “Display1_DownScalingSupported” (Ctrl-F) in the registry and change the value from 0 to 1


  4. Repeat for additional entries of “Display1_DownScalingSupported” (F3 for Find Next) in the registry
  5. Reboot
  6. Go back to the Search entry as done in step 1
  7. Select the “Settings” option and type in “display” into the search box
  8. Select “Change display settings” and adjust the screens resolution to either 1024x768 or 1152x864.


Now we have a resolution that we can experience most of Windows 8 with.  The only thing we’re missing out on is the ability to “snap” apps, which isn’t that big a deal.



As mentioned above in the “Warning Before Installation” section, after installation there may be issues with the fn keys not working.  The WIFI started in the “off” state and without the fn key combo functionality there was no way to turn it on.  After plugging in an Ethernet cable and a few Google searches later I found this post from Jesse B Andersen describing the drivers required to get the fn keys and power management to work.

Sam, thanks for sharing the 64bit experience! I'm unsure if the drivers from Lenovo are meant to work with 64bit, but you are our first 64bit tester.
The brightness setting could be part of Lenovo's Energy Management. The Fn stuff is from the Intel Chipset driver if I remember right.

Go to Lenovo’s drivers download page and install the drivers from the Chipset category for Windows 7. 


At this point most fn keys should be working.  Since Lenovo’s drivers wire up the fn key for WIFI to Lenovo’s Energy Management suite, it needs to be installed as well.


After the installation WIFI should now be toggleable with the fn key and we’re good to go.  Note that the toggle window will only show in desktop mode.


Although installing Windows 8 Consumer Preview on the S10-3T can be a little involved and tricky at times, the payout in terms of usability and performance are well worth it.  Windows 8 has given my S10-3T a new lease on life.  It’s like a brand new machine.  The touch features are dead on, touch dragging, touch scrolling and pinch zooming work smoothly.  After seeing the performance benefits I’d have a hard time justifying reverting to Windows 7. Now I just have to figure out how to use it and how to put together a few test apps.

If you’re interested in dual booting with Windows 7 there’s a good guide posted at lucienkblog.wordpress.com


Converting BlogEngine.NET 2.5 to a Web Application

Posted in .NET | ASP.NET | C# | Open Source

BlogEngine.NET 2.5 is currently distributed as a Web Site Project (WSP).  The project makes use of some of the WSP’s features to be more flexible for non technical end users.  For more technical users, who can recompile as necessary and don’t mind getting their hands dirty, a Web Application Project (WAP) conversion can provide some utility that the WSP can not.  You can find a guide of the pros and cons of each approach on MSDN: Web Application Projects versus Web Site Projects.

Aside from a general preference of WAPs over WSPs my main reasons for converting are as follows:

  • Deploying to Windows Azure is simpler with WAPs (I’ve been toying with the idea of putting this puppy up there, with the recent price drop)
  • A single compiled assembly is easier to manage during deployment
  • Web.config transforms can only be done on WAPs

At the time of this post there are a handful of forums posts, wiki articles and blog posts which somewhat describe the process of conversion (I’ve included links to all of these at the end of the post).  None of them capture all of the steps involved in conversion and the steps that were included weren’t always well detailed as one would like. 

After reviewing all of the available info and performing the conversion several times myself.  Here are the steps I’ve come up with and that I followed for the conversion of this site:

  1. Pull down the BlogEngine.NET source code and open the solution in Visual Studio.
  2. Remove the BlogEngine.Net Website project from the solution.
  3. Navigate to the solution directory in Windows Explorer and rename the Website project’s folder from BlogEngine.NET to BlogEngine.NETOld or something similar.  Leave Windows Explorer open, we’ll be back there again.

  4. Add an ASP.NET Web Application project called “BlogEngine.NET” to the solution.

  5. Remove most of the default files from the new Web Application project, such that it looks like the image below.

  6. In Windows Explorer, copy all files except Bin & Obj from the renamed BlogEngine.NETOld folder  to the new created BlogEngine.NET folder.
  7. In Visual Studio, click the “Show All Files” icon in the Solution Explorer.
  8. Right click the newly displayed files (with the exception of the aspnet_client and obj folders) and select “Include in Project” until your Solution looks like the image below.  Note: don’t forget to include the files and folders below the Account, Add_Data, Scripts & Styles folders.

  9. Add a new folder called Custom_Code and move everything except the Helpers folder from App_Code folder to Custom_Code folder. 

    The app code directory is one of the major differences between WAP and WSP. Most of the files in app code need to be moved out of app code, to a non-magic-name directory. The Helpers, however, are Razor helper classes and will only work if you paste the directly into the razor views, or leave them in the App_Code directory.

    One consequence of moving the Extensions folder out of App_Code and into Custom_Code is that it will no longer be possible to view or edit the source code of an extension from the browser. This is good from a security perspective.

    If, however, you want that functionality, create an App_Code/Extension folder and place those extensions in there. Do not, however, put all the extensions back because some of the extensions that ship with the product have dependencies and need to be included in the main dll (like the captcha extension).

    Quoted from:
    Converting BlogEngine.net 2.5 to Web Application Project
  10. Create a Helpers folder under Custom_Code and move RazorHelpers.cs there from the Helpers folder in App_Code.  After steps 8 & 9 your Solution should be structured like the below image.

  11. After moving the files from App_Code to Custom_Code the build action may be incorrect on many of the class files.  For each of the files in Custom_Code change the build action to Compile in the Properties window.

  12. In the BlogEngine.NET project make sure you have the following references (use the versions if there are multiple versions available):


  13. Add a project reference to BlogEngine.Core.
  14. Since we’ve technically moved the App_Code into a new assembly, we need to let the app know where it’s at.  Update the Web.Config pages section as follows:
    <pages enableSessionState="false" enableViewStateMac="true" enableEventValidation="true" 
      controlRenderingCompatibilityVersion="3.5" clientIDMode="AutoID">
        <!--WAP FIX-->
        <!--<add namespace="App_Code.Controls" tagPrefix="blog"/>-->
        <add namespace="App_Code.Controls" assembly="BlogEngine.NET" tagPrefix="blog"/>
  15. I had the async ctp installed on my pc, which makes async a reserved word and causes a handful of exceptions, so we’ll need to fix that.  Rename parameter async to asyncResult in BlogEngine.NET/Custom_Code/Controls/Blogroll.ProcessResponse.

    //WAP FIX
    //private static void ProcessResponse(IAsyncResult async)
    private static void ProcessResponse(IAsyncResult asyncResult)
        //WAP FIX
        //GetRequestData data = (GetRequestData)async.AsyncState;
        GetRequestData data = (GetRequestData)asyncResult.AsyncState;
        Blog.InstanceIdOverride = data.BlogInstanceId;
        var blogReq = data.BlogRequest;
            //WAP FIX
            //using (var response = (HttpWebResponse)blogReq.Request.EndGetResponse(async))
            using (var response = (HttpWebResponse)blogReq.Request.EndGetResponse(asyncResult))
                var doc = new XmlDocument();
                var responseStream = response.GetResponseStream();
  16. There’s a naming collision in themes between StandardSite and TitaniumX (WAP class names need to be unique). Rename BlogEngine.NET/themes/TitaniumX/site.master.cs from StandardSite to TitaniumSite class, change inherits in BlogEngine.NET/themes/TitaniumX/site.master as well.

    <%@ Master Language="C#" AutoEventWireup="true" Inherits="TitaniumSite " Codebehind="site.master.cs" %>
    <%@ Import Namespace="BlogEngine.Core" %>
    <% //WAP FIX 
       //<%@ Master Language="C#" AutoEventWireup="true" CodeFile="site.master.cs" Inherits="StandardSite " %>

    using System;
    using System.Web;
    using System.Web.UI;
    using System.Web.UI.HtmlControls;
    using BlogEngine.Core;
    //WAP FIX
    //public partial class StandardSite : System.Web.UI.MasterPage
    public partial class TitaniumSite : System.Web.UI.MasterPage
  17. Update the BlogEngine.Core/Utils.CodeAssemblies method by replacing assembly names with BlogEngine.NET.

    public static IEnumerable<Assembly> CodeAssemblies()
        var codeAssemblies = new List<Assembly>();
        CompilationSection s = null;
        //WAP FIX
        //var assemblyName = "__code";
        var assemblyName = "BlogEngine.NET";
                s = (CompilationSection)WebConfigurationManager.GetSection("system.web/compilation");
            catch (SecurityException)
                // No read permissions on web.config due to the trust level (must be High or Full)
            if (s != null && s.CodeSubDirectories != null && s.CodeSubDirectories.Count > 0)
                for (var i = 0; i < s.CodeSubDirectories.Count; i++)
                    assemblyName = string.Format("App_SubCode_{0}", s.CodeSubDirectories[i].DirectoryName);
                //WAP FIX
                //var assemblyName = "App_Code";
                assemblyName = "BlogEngine.NET";
  18. Update BlogEngine.Core/Web/Extensions/ManagedExtension.GetPathAndFilename  to point to the proper filename.

    public string GetPathAndFilename(bool checkExistence)
        string filename = string.Empty;
        var appRoot = HostingEnvironment.MapPath("~/");
        var codeAssemblies = Utils.CodeAssemblies();
        foreach (Assembly a in codeAssemblies)
            var types = a.GetTypes();
            foreach (var type in types.Where(type => type.Name == Name))
                var assemblyName = type.Assembly.FullName.Split(".".ToCharArray())[0];
                assemblyName = assemblyName.Replace("App_SubCode_", "App_Code\\");
                var fileExt = assemblyName.Contains("VB_Code") ? ".vb" : ".cs";
                //WAP FIX
                //filename = appRoot + Path.Combine(Path.Combine(assemblyName, "Extensions"), Name + fileExt);
                filename += Path.Combine("Custom_Code\\Extensions", Name + fileExt);
  19. Although this may not be absolutely necessary, since in WAP we won’t be writing changes to cs files from the admin screens anyway, it’s a good idea to clean up loose ends just the same. Update BlogEngine.NET/admin/Extensions/Editor.cshtml.

    var extensionFilename = ext.GetPathAndFilename(false);
    //WAP FIX
    //var canWrite = Utils.CanWrite(Href(Utils.ApplicationRelativeWebRoot + "App_Code/Extensions"));
    var canWrite = Utils.CanWrite(Href(Utils.ApplicationRelativeWebRoot + "Custom_Code/Extensions"));
    var fileExists = !string.IsNullOrWhiteSpace(extensionFilename) && File.Exists(extensionFilename);
  20. Convert to Web Application.


  21. Success!

All in all the conversion wasn’t the most straight forward process, but not excessively complex by any means.  The most difficult part was nailing down the correct steps and the correct sequence.  After that, the conversion could be performed in under 30 mins.  If there’s enough interest, I’ll upload a converted solution to GitHub.

For more information about BlogEngine.NET http://www.dotnetblogengine.net/ or http://blogengine.codeplex.com/