Sign up for a free trial

This is easy AND low cost. Turn up to the sign-up page for most major players and you’ll get free or low-cost services for a timed period. Sure, you couldn’t start the next Facebook at this level, but it will give you enough to start to learn what’s on offer.  You can run VMs, deploy solutions, utilise IaaS, PaaS and SaaS offerings and generally kick the tyres of the features of each. At time of writing these are:

• Amazon Web Services (AWS) Free Usage Tier – 12 months: http://aws.amazon.com/free/
• Google App Engine – each app gets a portion of free resource usage: https://developers.google.com/appengine/kb/billing#freequota
• Rackspace Cloud – no published information on any form of free resource usage tier.
• Windows Azure Free Trial – 3 months: http://www.windowsazure.com/en-us/pricing/free-trial/
• Office 365 – depending on your license level you can get a free developer site setup.  If you don’t qualify then a 30 day trial is available. http://msdn.microsoft.com/en-us/library/jj692554.aspx

Learn the APIs and use the SDKs

Each of Amazon, Azure, Google, Office 365 and Rackspace offer some form of remote programmable API (typically presented as REST endpoints).  If you’re going to move into Cloud from traditional hosting or system development practices then starting to learn about programmable infrastructure is a must.  Understanding the APIs available will depend on leveraging existing documentation:

• Amazon Web Services: Pretty much every AWS component has its own REST API – the best thing to do is utilise the available documentation to identify the REST APIs you want to use: http://aws.amazon.com/documentation/
• Google App Engine: Again, documentation is your start: https://developers.google.com/appengine/docs/
  
• Rackspace Cloud: http://docs.rackspace.com/
• Windows Azure: Like AWS each component of Azure provides a REST API: http://msdn.microsoft.com/en-us/library/windowsazure/ff800682.aspx
  
• Office 365: as this platform is a combined offering, each of the products on offer (AD, Exchange, Lync and SharePoint) provide various APIs that can continue to be used in a relatively consistent state with their on-premise equivalents.  Documentation is spread about a bit on MSDN but here’s a taster:
  • Exchange Web Services: http://msdn.microsoft.com/en-us/library/exchange/dd877012(v=exchg.150).aspx
  • Lync via Unified Communications Web API (UCWA): http://ucwa.lync.com/documentation/api-reference
  • SharePoint REST API: http://msdn.microsoft.com/en-us/library/jj860569.aspx

If you aren’t a fan of working so close to the wire you can always leverage one of the associated SDKs in the language of your choice:

• Amazon Web Services: .Net, Java, Node.js, PHP, Python and Ruby. Mobile: iOS and Android. http://aws.amazon.com/code/
• Google App Engine: Java, Python and Go. https://developers.google.com/appengine/downloads
  
• Rackspace Cloud: .Net, Java, PHP, Python and Ruby. http://docs.rackspace.com/sdks/guide/content/intro.html
• Windows Azure: .Net, Java, Node.js, PHP, Python and Ruby. Mobile: Windows Phone (C#), iOS and Android. http://www.windowsazure.com/en-us/downloads/
  
• Office 365: You can utilise .Net native SDKs for the individual products or leverage JavaScript where available.

The great thing about having .Net support is you can then leverage those SDKs directly in PowerShell and automate a lot of items via scripting.

Developer Tool Support

While having an SDK is fine there’s also a need to support developers within whatever IDE they happen to be using.  Luckily you get support here too:

• Amazon Web Services: Toolkit for Visual Studio: http://aws.amazon.com/visualstudio/ (also on Nuget) or for Eclipse: http://aws.amazon.com/eclipse/.
• Google App Engine: Eclipse: https://developers.google.com/eclipse/ 
  
• Rackspace Cloud: there is a Visual Studio plugin for Visual Studio 2010 but the page is offline at time of writing and there’s no news on it being updated to support Visual Studio 2012.
• Windows Azure: Visual Studio can build Cloud Applications using project templates and there is also support for Eclipse: http://msdn.microsoft.com/en-us/library/windowsazure/hh694271.aspx

Source Control and Release Management

The final piece of the puzzle and one not necessarily tied to the individual Cloud providers is where to put your source code and how to deploy it.

• Amazon Web Services: You can leverage Elastic Beanstalk for deployment purposes (this is a part of the Visual Studio and Eclipse toolkits). http://aws.amazon.com/elasticbeanstalk/
• Google App Engine: Depending on language you have a few options for auto-deploying applications using command-line tools from build scripts.  Eclipse tooling (covered above) also provides deployment capabilities.
  
• Rackspace Cloud: no publicly available information on build and deploy.
• Windows Azure: You can leverage deployment capabilities out of Visual Studio (probably not the best solution though) or utilise the in-built Azure platform support to deploy from a range of hosted source control providers such as BitBucket (Git or Mercurial), Codeplex, Dropbox (yes, I know), GitHub or TFS.  A really strong showing here from the Azure platform! http://www.windowsazure.com/en-us/develop/net/common-tasks/publishing-with-git/

So, there we have it – probably one of the most link-heavy posts you’ll ever come across – hopefully the links will stay valid for a while yet!  If you spot anything that’s dead or that is just plain wrong leave me a comment.

HTH.

As part of the project I’m leading at Kloud at the moment we are rebuilding an Intranet so it runs on SharePoint Online 2013 so I wanted to share some of the Application Lifecycle Management (ALM) processes we’ve been using.

Packaging

Most of the work we have been doing to date has leveraged existing features within the SharePoint core – we have, however, spent time utilising the Visual Studio 2012 SharePoint templates to package our customisations so they can be moved between multiple environments. SharePoint Online still provides support for Sandboxed Solutions and we’ve found that they provide a convenient way to deploy elements that are not developed as Apps. Designer packages can also be exported and edited in Visual Studio and produce a re-deployable package (which result in Sandboxed Solutions).

Powershell

At the time of writing, the number of Powershell Commandlets for managing SharePoint Online are substantially less those for on-premise. If you need to modify any element below a Site Collection you are pretty much forced to write custom tooling or perform the tasks manually – we have made a call in come cases to build tooling using the Client Side Object Model (CSOM) or to perform tasks manually.

Development Environment

Microsoft has invested some time in the developer experience around SharePoint Online and now provides you with free access to an “Office 365 Developer Site” which gives you a single-license Office 365 environment in which to develop solutions. The General Availability of Office 365 Wave 15 (the 2013 suite) sees these sites only being available for businesses holding enterprise (E3 or E4) licenses.  Anyone else will need to utilise a 30 day trial tenant.

We have had each team member setup their own site and develop solutions locally prior to rolling them into our main deployment. Packaging and deployment is obviously key here as we need to be able to keep the developer instances in sync with each other and the easiest way to achieve that is with WSPs that can be redeployed as required.

One other item we have done around development is to utilise an on-premise setup in a VM to provide developers with a more rapid development experience in some cases (and more transparent troubleshooting). As you mostly stick to the SharePoint CSOM a lot of your development these days resides in JavaScript which means you shouldn’t hit any snags in relying in on-premise / full-trust features in your delivered solutions.

Note that the Office 365 Developer Site is a single-license environment which means you can’t do multi-user testing or content targeting. That’s where test environments come into play!

Test Environment

The best way to achieve a more structured ALM approach with Office 365 is to leverage an intermediate test environment – the easiest way for anyone to achieve this is to register for a trial Office 365 tenant – while only technically available for 30 days this still provides you with the ability to test prior to deploying to your production environment.

Once everything is tested and good to go into production you’re already in a position to know the steps involved in deployment!

As you can see – it’s still not a perfect world for SharePoint ALM, but with a little work you can get to a point where you are at least starting to enforce a little rigour around build and deployment.

Hope this helps!

Useful Links

• Provision an Office 365 Developer Site. (Note: no longer valid with GA of Wave 15).
• Provision a Developer Site using your existing Office 365 subscription.
• View SharePoint Online Powershell Commandlets.

Traditionally timer jobs played a large part in the way background services could be implemented in SharePoint. You will find that timer jobs are absent in SharePoint Online and that the alternative is to leverage the workflow capabilities of SharePoint to achieve the same sort of outcome.

A fairly typical scenario for timed jobs is to poll external services for some form of information to be cached locally on SharePoint. The good news is that the standard Call HTTP Web Service Action of SharePoint 2013 workflows execute the same in Office 365 as they do on-premise.

There is a blog post and demo on MSDN that you can use to test this out for yourself.

Gotcha: and a fairly big (and unobvious) one: this workflow Action can only handle calls to webservices that return responses of type text/html, text/plain and application/json. You will find you are unable to accept and process text/xml responses and the Action will only pipe the response from a webservice call to a Dictionary object so you can’t even do any string manipulation foo on the result if it’s not one of the three response types accepted!

Hope this post saves you some time!

Firstly, a few key things:

1. Read and absorb the tutorial on how best to work with Git from the guys over at Atlassian.

http://atlassian.com/git/tutorial/git-basics

2. Install the Visual Studio 2012 Update 2 (currently in CTP, possibly in RTM by the time you read this).
http://www.microsoft.com/en-us/download/details.aspx?id=36539 (grab just vsupdate_KB2707250.exe)

3. Install the Git Tools for Visual Studio http://visualstudiogallery.msdn.microsoft.com/abafc7d6-dcaa-40f4-8a5e-d6724bdb980c

4. Install the most recent Git client software from http://git-scm.com/downloads

5. Set your default Visual Studio Source Control provider to be “Microsoft Git Provider”.

6. Setup an account on Team Foundation Service (https://tfs.visualstudio.com/), or if you’re lucky enough maybe you can even do this with your on-premise TFS instance now…

7. Make sure you enable and set alternative credentials in your TFS profile:

8. Setup a project that uses Git for source control.

At this stage you have a couple of options – you can clone the repository using Visual Studio’s Git support

OR you can do it right from the commandline using the standard Git tooling (make sure you’re at a good location on disk when you run this command):

git clone https://thesimpsons.visualstudio.com/defaultcollection/_git/bart milhouse
Cloning into 'milhouse'...
Username for 'https://thesimpsons.visualstudio.com/': homer
Password for 'https://thesimpsons.visualstudio.com/':
Warning: You appear to have cloned an empty repository.

I tend to setup a project directory hierarchy early on and with Git support in Visual Studio I’d say it’s even more important as you don’t have a Source Control Explorer view of the world and Visual Studio can quickly create a mess when adding lots of projects or solution elements.  The challenge is that (as of writing) Git won’t support empty folders and the easiest work around is to create your folder structure and drop an empty file into each folder.

Now this is where Visual Studio’s Git tools won’t help you – they have no concept of files / folders held outside of Visual Studio solutions so you will need to use the Git tools at the commandline to affect this change. Once have your hierarchy setup with empty files in each folder, at a command prompt change into the root of your local repository and then do the following.

git add -A
git commit -m "Hmmmm donuts."

Now, at this point, if you issue “git push” you may experience a problem and receive this message:

No refs in common and none specified; doing nothing.
Perhaps you should specify a branch such as ‘master’.
Everything up-to-date.

Which apart from being pretty good english (if we ignore ‘refs’) is pretty damn useless.

How to fix? Like this:

git push origin master

This will perform a forced push and your newly populated hierachy should be pushed to TFS, er Git, er TFS. You get the idea. Then the others on your team are able to clone the repository (or perform a pull) and will receive the updates.

HTH.

Update: A big gotcha that I’ve found, and it results in a subtle issue is this: if you have a project that has spaces in its title (i.e. “Big Web”) then Git happily URL encodes that and will write the folder to disk in the form “Big%20Web” which is all fine and dandy until you try to compile anything in Visual Studio. Then you’ll start getting CS0006 compilation errors (unable to find metadata files).  The fix is to override the target when cloning the repository to make sure the folder is validly named (in my example above this checks out the “bart” project to the local “milhouse” folder).

Peak hour traffic

We’ve all driven on roads during peak hour – what a nightmare! A short trip can take substantially longer when the traffic is heavy. Processes like paying for tolls or going through traffic lights suddenly start to take exponentially longer which has a knock-on effect to each individual joining the road (and so on). I’m pretty sure you can see the analogy here with the peaks in demand that websites often have, but, unlike on the road the web has this problem two-fold because your request generates a response that has to return to your client (and suffer a similar fate).

At a very high level the keys to better performance on the web are:

• ensure your web infrastructure takes the least amount of time to handle a request
• make sure your responses are streamlined to be as small as possible
• avoid forcing clients to make multiple round-trips to your infrastructure.

All requests (and responses) are not equal

This is subtle and not immediately obvious if you haven’t seen how hosts with different latencies can affect your website. You may have built a very capable platform to service a high volume of requests but you may not have considered the time it takes for those requests to be serviced.

What do I mean?

A practical example is probably best and is something you can visualise yourself using your favourite web browser. In Internet Explorer or Chrome open the developer tools by hitting F12 on your keyboard (in IE make sure to hit “Start Capturing” too) – if you’re using Firefox, Safari, et al… I’m sure you can figure it out . Once open visit a website you know well and watch the list of resources that are loaded. Here I’m hitting Google’s Australia homepage.

I’m on a very low latency cable connection so I have a response in the milliseconds.

This means that despite the Google homepage sending me almost 100 KB of data it serviced my entire request in under half a second (I also got some pre-cached goodness thrown in which also makes the response quicker). The real interest beyond this is what is that time actually made up of? Let Chrome explain:

My client (browser) spent 5ms setting up the connection, 1ms sending my request (GET http://www.google.com.au/), 197ms waiting for Google to respond at all, and then 40ms receiving the response. If this was a secure connection there would be more setup as my client and the server do all the necessary encryption / decryption to secure the message transport.

As you can imagine, if I was on a high latency connection each one of these values could be substantially higher. The net result on Google’s infrastructure would be:

• It takes longer to receive the full request from my client after connection initialisation
• It takes longer to stream the full response from their infrastructure to my client.

Both of which means my slower connection would use Google’s server resources for longer thus stopping those resources servicing another request.

As you can see this effectively limits the infrastructure to run at lower capacity than it really could and also demonstrates why performing load testing requires that you run test agents that utilise different latencies so you can gauge realistically what your capacity is.

Some things you can do

Given you have no control over how or where the requests will come from there are a few things you can do to help reduce the effect of low latency clients will impact your site.

1. Reduce the number of requests or round trips: often overlooked but is increasingly becoming easier to achieve. The ways you can achieve a reduction in requests include:
   1. Use a CDN for resources: Microsoft and Google both host jQuery (and various jQuery plugins) on their CDNs. You can leverage these today with minimal effort. Avoid issues with SSL requests by mapping the CDN using a src attribute similar to “//ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js” (without the http: prefix). Beyond jQuery push static images, CSS and other assets to utilise a CDN (regardless of provider) – cost should be no big issue for most scenarios.
   2. Bundle scripts: most modern sites make heavy use of JavaScript and depending on how you build your site you may have many separate source files. True, they may only be a few KB but each request a client makes will need to go through a process similar to the above. Bundling refers to the combining of multiple JavaScript files into a single download. Bundling is now natively supported in ASP.Net 4.5 and is available in earlier versions through third-party tooling for either runtime or at-build bundling. Other platforms and technologies offer similar features.
   3. Use CSS Sprites: many moons ago each individual image reference in CSS would be loaded as an individual asset onto your server. While you can still do this the obvious net effect is the need to request multiple assets from the server. CSS sprites combine multiple images into one image and then utilise offsets in CSS to show the right section of the sprite. The upside is also client-side caching means any image reference in that sprite will be serviced very quickly.
   4. Consider inline content: there I said it. Maybe include small snippets of CSS or JavaScript in the page itself. If it’s the only place it’s used why push it to another file and generate a second request for this page? Feeling brave? You could leverage the Data URI scheme for image or other binary data and have that inline too.
2. Reduce the size of the resources you are serving using these approaches:
   1. Minification: make sure you minify your CSS and JavaScript. Most modern web frameworks will support this natively or via third-party tooling. It’s surprising how many people overlook this step and on top of that also don’t utilise the minified version of jQuery!
   2. Compress imagery: yes, yes, sounds like the pre-2000 web. Know what? It hasn’t changed. This does become increasingly difficult when you have user generated content (UGC) but even there you can provide server-side compression and resizing to avoid serving multi-MB pages!
   3. Use GZIP compression: there is a trade-off here – under load can your server cope with the compression demands? Does the web server you’re using support GZIP of dynamic content? This change, while typically an easy one (it’s on or off on the server) requires testing to ensure other parts of your infrastructure will support it properly.
3. Ensure you service requests as quickly as possible – this is typically where most web developers have experience and where a lot of time is spent tuning resources such as databases and SANs to ensure that calls are as responsive as possible. This is a big topic all on its own so I’m not going to dive into it here!

If you’re a bit lost were to start it can pay to use tools like YSlow from Yahoo! Or PageSpeed from Google – these will give you clear guidance on areas to start working on. From there it’s a matter of determining if you need to make code or infrastructure changes (or both) to create a site that can scale to more traffic without needing to necessarily obtain more compute power.

Hope you’ve found this useful – if you have any tips, suggestions or corrections feel free to leave them in the comments below.

So why am I blogging about it?

One item called out in the post is the sub-heading attached to each specialisation of “Network & Communications”, “Software Engineer”, “Electrical & Electronic Engineering”.  Sure, they’re simplifications and questionably accurate, but for most people of any age they are as detailed as needed to provide a flavour of what each is about.

I think that as technology professionals and as citizens in a very tech-savvy world we assume the detail of what we do for a job can be explained to and comprehended by most of the population around us.  While this may be true to a degree, I bet if you asked most non-tech people you know to explain what you do for a job (without you first giving them a detailed refresher) they may explain it as:

“Writes software for computers”

“Creates websites”

“Looks after networking at company X”

“Helps people access the internet”.

Sure, they’re not detailed and they most likely fail to capture in any way the complexity of your job.  But they are the way those people have understood what you do for a job and most likely reflect how most people would interpret it.

As professionals we should not be insulted by this.

A key role for the ACS is to help drive the next generation of professionals into our businesses whatever their background.  The ACS simplify the descriptions because they must.  You cannot explain a new concept with another in less characters than a Tweet.

Here’s a challenge – come up with a sub-heading that describes those specialisations in terms that the general public can understand, that captures the job’s main purpose and that fits in that space.  Then Tweet it to the ACS.

My team is using it to deploy a range of .Net websites and we’re considering it for pushing database changes too (although these days a lot of what we build utilises Entity Framework so we don’t need to push that many DB scripts about any more) and one thing we’ve done a lot of is deploy Umbraco 4 sites.

Its About The Code

One important fact to get out here is that I’m only going to talk about how Octopus will help you deploy .Net code changes only.  While you can generate SQL scripts and deploy them using Octopus (and ReadyRoll perhaps), Umbraco development has little to do with schema change and everything to do with instance data change.  This is not an easy space to be – more so with larger websites – and even Umbraco has found it hard to solve despite producing Courier specifically for this challenge.  This all being said, I’m sure if you spend time working with SQL Data Compare  you can come up with a database deployment step using scripts.

Setting It Up

Before you start Umbraco deployments using Octopus you need to make a decision about what to deploy each time and then modify your target.

When developing with Umbraco you will have a “media”, an “umbraco” and an “umbraco_client” folder in your solution folder but not necessarily included in your Visual Studio solution.  These three folders will also be present on your target deployment server and in order to leverage Octopus properly you need to manage these three folders appropriately.

Media folder

This folder holds files that are uploaded by CMS users over time.  It is rare that you would want to take media from a development environment and push it to any other environment other than on initial deployment.  If you do deploy it each time then your deployment will be (a) larger and (b) more challenging to deploy (notice I didn’t say impossible).  You’ll also need to deal with merging of media “meta data” in the Umbraco CMS you’re deploying to (you’re back at Courier at this stage).

Regardless of whether you want to push media or not you will need to deal with how you treat the media folder on your target server – Octopus can automatically re-map your IIS root folder for your website to your new deployment so you’lll need to write Powershell to deal with this (and merging content if required).

Our team’s process is to not transfer media files via Octopus and we have solved the media folder problem by creating the folder as a Virtual Directory in IIS on the target web server.  As long as the physical folder has the right permissions you will have no problems with this approach.  The added benefit here is that when Octopus Deploy remaps your IIS root folder to a new deployment the media is already in place and not affected at all.

Umbraco folders

The two Umbraco folders are required for the CMS to function as expected.  While some of you might make changes internally to these folders I’d recommend you visit your reasons for doing so and see if you can’t make these two folders static and simply re-deploy the Umbraco binaries in your Octopus package.

There are a couple of ways to proceed with these folders – you can choose to redeploy them each time or you can treat them as exceptions and, as with the media folder, you can create Virtual Directories for them under IIS.

If you want to redeploy them as part of your package you will need to do a few things:

1. Create a small stub “umbraco.zip” that is empty or that contains a single file (or similar) in your Visual Studio solution.
2. Write some Powershell in your PostDeploy.ps1 file that unzips those folders into the right place on your target web server.
3. In your build script (on your build server, right?) utilise an appropriate MSBuild extension (like the trusty MSBuildCommunityTasks) to zip the two folders into a zip that replaces the sub you created in (1).
4. Run your build in Release mode (required to trigger OctoPack) which will trigger the packaging of your outputs including the new zip from (1).

On deployment you should see your Powershell execute and unpack your Umbraco folders into the right place!

Alternatively, you can choose not to redeploy these two folders each time – if this suits (and it does for us) then you can use the same approach as with the media folder and simply create two Virtual Directories.  Once you’ve deployed everything will work as expected.

It’s Packaged (and that’s a Wrap)

So there we have a simple scenario for deploying Umbraco via Octopus Deploy – I’m sure there are more challenging scenarios than the above but I bet with a little msbuild and Powershell-foo you can work something out.

I hope you’ve found this post useful and I’d recommend checking out the Octopus Deploy Blog to see what great work Paul does at taking feedback on board for the product.

How to solve

The answer, it turns out, is fairly easy (if a little convoluted) – Windows Server Backup PLUS EBS snapshots.

In order for this to work you will need:

1. Windows Server Backup installed on your Instance (this does not require a reboot on install).

2. An appropriately sized EBS volume to support your intended backup (see the Technet arcticle on how to work out your allowance – remember you can always create a new volume later if you get the size wrong!)

3. Windows Task Scheduler (who needs Quartz or cron ).

4. Some Powershell Foo.

Volume Shadow Copy using the new EBS Volume

Once you have created your new EBS volume and attached it to the Instance you want to backup, open up Windows Server Backup and select what you want to backup (full, partial, custom – to be honest you shouldn’t need to do a “bare metal” backup….)  Note that Windows Server Backup will delete *everything* on the target EBS volume and it will no longer show up in Windows Explorer – it will still be attached and show up in Disk Manager, but you can’t copy files to or from it.

The benefit of Windows Server Backup is that it will utilise Windows Volume Shadow Copy Service (VSS)  resulting in a clean copy of files – even those in-flight at the time of backup.  This gets around the inability to “freeze” NTFS at runtime.

Set your schedule and save the backup.

Snapshot the backup volume

Now you have a nice clean static copy of the filesystem you can go ahead and create an EBS snapshot.  The best way I found to schedule this was to use some Powershell magic written by the guys over at messors.com.  I slightly modified the Daily Snapshot Powershell to snapshot a pre-defined Instance and Volume by calling the CreateSnapshotForInstance function that takes an Instance and Volume identifier.  The great thing with this script setup is it auto-manages the expiry of old snapshots so my S3 usage doesn’t just keep on growing.

I invoke this Powershell on the success of the initial Windows Server Backup scheduled task by using the Task Scheduling – see this post at Binary Royale on how to do this (they send an email – I use the same approach to do a snapshot instead).

The great thing about the Powershell is that it will send you an email once completed – I have also setup mail notifications at completion of the Windows Server Backup (success, failure, disk full) so I can know when / if the backup fails at an early stage.  Note that in Windows Server 2008 R2 you can send an email right in Windows Task Scheduler – on AWS you’ll need to have an IIS smart host up and running to support this though – see my earlier post on how to set up a IIS SES relay host.

Summary

The benefit of this approach is a consistent state for your backup contents as well as an easy way to do a controlled restore at a later date (“create volume from snapshot” in the AWS management console and then attach to an Instance).  Additionally you achieve a reasonably reliable backup for not much more than the cost of EBS I/O and S3 I/O and storage costs.

Hope you find this useful.

First off, I’m tech guy, and on top of that I am primarily a Microsoft tech guy, so you may expect me to have better-than-average abilities when picking up new concepts as they are introduced in each iteration of Windows.  Anyway, here it goes, a few random musings from me on Windows 8 and why I should really have called this post “8 Shades of Meh”. Apologies if it just jumps to about a bit…

Desktop Users Will Survive

Having not had the chance to play with Windows 8 on a new form factor like a Surface tablet it’s hard to know what the experience will be there, but I can tell you that as a desktop user (I’m running it on a Lenovo T420s notebook) that you will not be lost.  Sure, you’ll need to retrain yourself for a few basic actions (see what follows below) but for the most part you will come to wonder what all the fuss was about.  Once you drop into the Desktop you will be fine (and you can still put icons on the desktop and pin things to the task bar). Control Panel is still there as are a bunch of other well known Windows utilities (finally, it’s “File Explorer” instead of “Windows Explorer”!).  Goodness me, desktop peek is still there too!

I’d say overall, that the effort involved in familiarising yourself with Windows 8 will be less than that involved in picking up the Ribbon when it was introduced into Office.

Square Edges, Flat Palettes

Yes, everyone said it – the death of Aero!  And to your average user this means what exactly? It probably means their ancient machine that was smashed with Vista could probably be resurrected better on Windows 8 than even on Windows 7 (assuming there are drivers about).

I’ll be honest and say I don’t miss transparent bars at all (one reason I like Chrome is that it actually does something useful with that space!) and what little transparency there is (the task bar is transparent) is fine with me.

I also jumped onto an Office 2013 Preview build when I switched to Windows 8 and have been using Visual Studio 2012 for a while.  I’ve square-cornered-flat-paletted all teh things.  You get used to it!

There’s no Start Menu

+1 from me on this.  I get a few more pixels back for stuff on the Taskbar when in Desktop Mode.  Also, for the first time ever in its lifetime, you’ll actually start to use the Windows key.  My tip (and one I read elsewhere a lot): learn Windows keyboard shortcuts.  The Windows key is the new Escape key in many circumstances.  If Escape no longer does what you expect try the Windows key!  Still lost? Mouse-over the bottom left of screen (on any monitor) and the Start Screen can be activated with a click (just hit the Windows key is my advice).

One bit I don’t get (and I’m sure there’s a reason) is that from time-to-time my Start screen pops on my secondary monitor instead of my primary… weird!

Multi-monitor Taskbar

Took a little while to get used to this – still breaking years of single-monitor Taskbar-ness.  Getting into the habit of looking at the Taskbar on the screen that you have an application (or an application window) open on takes a little getting used to, but it’s nice to finally have this natively in Windows.

Windows 8 Will Kill Off XP

I think corporates will probably take one look at Windows 8 and decide that Windows 7 will be the basis of their new SOE builds. I’d love to see people finally get off of Windows XP and if Windows 8 can make that happen by forcing uptake of Windows 7 it’s a good thing!  God knows it hurts me the number of times I go somewhere and still see XP in use.  The one saving grace for Windows 8 in the corporate environment is if the tablet form factor for Windows 8 really rocks then perhaps we might just see Windows 8 across the board (desktop, Surface tablet and phone).

Search All The Things

The habit for most Windows 7 power users was search.  Translate that to Windows 8 and you’re good to go.  Search has been refined slightly but overall behaves pretty much the same.

So… What?

In summary, I think it’s incorrect to call Windows 8 the next Vista.  If anything, I’d say Microsoft has played things pretty safe.  They could have made the experience far more radical than it is and I think (as I said) that traditional desktop users won’t struggle too much.  There’s certainly a shift going on right now that started with touch computing that is finally being embraced in Windows 8.   If you have been using computers for a while Windows 8 looks odd (and might remind you a bit of “Active Desktop”), but think of the generation of people coming through now for whom the iPhone and iPad are points of reference for how to use a computer and consider what Windows 8 (and future releases) will mean to them.

If you’re up for a new machine, get Windows 8, especially if you’re on XP (please!)

One blog I’d recommend having a read of if you’re unsure what Windows 8 means to you as a Windows 7 user is from Scott Hanselman.  Certainly helped me decide to make the switch.

One reason I decided to jump onto the Windows 8 bandwagon was that I finally had access to a native VM environment that supports 64 bit operating systems.  Unfortunately, though, I’ve just burnt a couple of hours trying to figure out how to get Hyper-V and Windows 8 to play nicely with one another at a networking level.

My problem presented itself as loss of IP network connectivity which meant my host didn’t have any form of network access.

A quick look around online suggests a few people have had problems as well that sound way, way worse than mine (re-install the host OS, really?!)

The Solution(s)

This may not work for everyone… I’m running a Lenovo T420s that has the out-of-the-box Windows 8 drivers for all its components as Lenovo haven’t moved past beta with their drivers as yet.

Network adapters are: wired: Intel 82579LM Gigabit; wireless: Lenovo 11b/g/n Wireless LAN PCI Express.

I have this approach working for the wired and wireless connections in my machine – the fix is slightly different for each connection type, so here they are.

Wired

1. Create Your virtual switch and change no defaults (apart from the Name if you like).  This is how it looks:

After you apply this your underlying physical connection will cease working.

2. Open up Control Panel > Network and Internet > Network Connections.

You will find that you now have “Ethernet” and “vEthernet (Your Switch Name)” connections.

3. Right click on “Ethernet” and click “Properties”.  Under the Networking Tab select all items in the “This connection uses the following items” and then click “OK”.

Windows will now give you a nice warning about items being disabled (such as IPv4, etc).  Click “Yes” on this dialog.

At this point you will see the “vEthernet” connection suddenly switch to “Identifying…..” and a few moments later you’ll be connected to your network (if you’re on a Windows domain the domain name will show).

Wireless

This process is slightly different as using a Wireless connection creates a Network Bridge as part of the process of setting up a Virtual Switch.

Do the above steps but select your wireless network connection instead this time.

When you are finished you will see two new items in your Network Connections: “vEthernet (Your Wireless Switch Name)” and “Network Bridge”.

Right click on the “Network Bridge” and click “Properties”. Under the Networking Tab select all items in the “This connection uses the following items” and then click “OK”.

Windows will now give you a nice warning about items being disabled (such as IPv4, etc).  Click “Yes” on this dialog.

As with the Wired connection above you should now see your “vEthernet” (wireless) connection switch to “Identifying…” followed shortly by a working network connection.

That’s it – simple – no reinstalling or driver updates are any other shenaningans.

Enjoy your Windows 8 – x64 Hyper V environment!

BTW – you shouldn’t need to jump through all these hoops to get this working and I’m not sure why these problems happen – I was very close to switching back to VirtualBox but thought I’d have one last go.  I’m hoping a future update from Microsoft will resolve these sorts of problems.

Update

I have had a few issues with Wireless – primarily I think due to roaming between different types of wireless networks – my initial setup was on a Windows domain and when I tried to connect wirelessly on my home network (running via a Cisco home business device) I couldn’t get a connection.  After a few days working on wired I’ve just switched back to wireless and it’s all working well (surprisingly).  So… you’re mileage may vary for wireless setups.  Let me know your experiences and I’m happy to add links to useful blogs or fixes for these sorts of issues.

I find that if wireless isn’t working that you need to disable your Wireless Virtual Switch on Windows 8 and re-enable it and you should find that the connection comes back to life.