Welcome to blogs.conchango.com

Shrink yourself to the size of an ant and think of a classic server as a mini data centre. Banks upon banks of memory, multiple disks, many CPU cores and even network interfaces. The OS manages all of the many processes and threads, sharing the resources amongst them and when they demand more resource it makes it available to them – on demand and apparently instantly. Importantly all the resources in my mini data centre genuinely appear as one enormous pool available to all my applications at once. My application runs in a process and doesn’t care whether it consumes one core or 8. So what is a cloud OS?

Cloud OSes do appear to be quite different because somehow I need to play a part traditionally played by the OS. When my application demands more resources I get involved. Typically I need to allocate more virtual machines or storage and quite likely I need to tell my application to extend itself into this new resource (i.e. install my application components and bring it into the pool/farm/cluster/you-name-it). Then when that demand passes I need to consider releasing those resources.

Consider for a moment too the utility model, or to use a common analogy: “cloud computing is like the power grid – on demand, just in time, scale up and down”. When I need to consume more power, the statistically multiplexed grid allows me to draw as much as I want. There are even special burst providers like pumped storage schemes to handle the gigantic surge of kettles going on after a football game. If I need a milliamp for a second or 10 amps for an hour it makes no odds to me(!).

Again the cloud seems to break this analogy. My application will consume up to the limit of pre-allocated resources and stop. The data centre might have a potential for a billion petaflops but the cloud OS can’t just grant them to my app. It is a bit like knowing that I am about to plug in my electric car and ringing the grid to provision me more current.

Once upon a time the server OS used to be quite crude but they evolved and we take their sophistication for granted now. Most people struggle to even describe what an OS does. At the moment I need to resort to special software like Appistry to help me virtualise my application so that when I auto scale up/down my Amazon machine images the application can do so too. How long before these capabilities are part of the cloud OS allowing applications to genuinely scale up and down very discretely? Will all the CPUs in the cloud data centre eventually present themselves as a single virtual resource with the cloud OS presenting abstractions, much like a regular process, as execution containers or in the cloud OS will the virtual machine always get in the way?

It feels as if the virtual machine is a convenient way of *currently* spanning large amounts of hardware, but is it a stop gap? Will a genuine cloud OS come along that behaves like a regular server OS atop a giant data centre? It will be happy to present 24TB of apparently contiguous RAM and 1000 cores to a single “process”. It will be like NUMA and move application data across the server farm to the CPU that has been scheduled to work on it. Do we need it? Are we content for the next few decades to worry about how to span virtual machines and make them collaborate and auto-scale? Is the VM the new Process?

P.S. I appreciate that in many clouds, storage capacity seems to have been the first to become a truly virtualised and discrete resource, although storage performance hasn’t (i.e. most solutions are too blunt to configure for different performance characteristics etc.)

When you have a web farm, monitoring can become a little bit more tricky. When you deploy a monitor  it is only monitoring the behaviour of the server chosen by the load balancer to respond. You need to create a monitor that is engaging each server directly, bypassing the load-balancer. Obvious, yes. Hard, no.

When you have a web farm to serve your web site you want to make sure that they are all serving the same content. Maybe post-deployment, or just on a regular interval you want to check that one server hasn’t failed to pick up a configuration change or been accidentally interfered with. Or perhaps, when another monitor detects a failure you want to see if the wrong content is displaying across all web servers or just one.

One thing you can do is to create a web page that includes an iFrame of each web server (bypassing the load balancer obviously). This is great for a quick eye-balling and may give the answer you need straight away. Sometimes the difference in a web page is not visual, or too subtle to spot in a hurry…

I feed my habit by coding on the train home and I knocked this PowerShell script together to line by line compare the output of a page across a farm. It is a start and has proved handy a couple of times to spot a problem. It can be vastly improved of course. For example: by repeating the script and passing different HTTP headers (emulating a different browser type) it can see whether Web Server A is serving different content to IE8 to Web Server D. That’d be hard to spot. Anyway, here it is:

$inputDocuments ="http://192.168.0.10/default.aspx","http://192.168.0.11/default.aspx","http://192.168.0.12/default.aspx","http://192.168.0.20/default.aspx","http://192.168.0.21/default.aspx"             

# Use this line if you would prefer the script actually ignored known patterns that different in each file
$patternList ="^\s*<input\s+type=""hiden""\s+value=""[^""]+""\s+/>","^[\s]*$"

functionMatchesKnownPattern ($inputLine)
{
   ForEach ($patternin$patternList)
    {
       $pat=[regex]$pattern
       if($pat.match($inputLine).Success)
        {
           return $TRUE
       }
    }
   return $FALSE
}

# For each document create a hash table of line number and the actual line. Exclude all lines that match a pattern known to be different in each document.
$parsedDocuments =@()
ForEach ($inputDocument in$inputDocuments)
{
    [regex]::Split((New-Objectnet.webclient).DownloadString($inputDocument),"\r\n") |ForEach-Object -begin{$count=0;$webLines=@{}}-Process{if(MatchesKnownPattern($_)){$webLines[$count]="KNOWN DIFFERENCE";$count++;}else{$webLines[$count]=$_;$count++;}}-End{$parsedDocuments +=$webLines}
}

# Look at each document and see if after all known different patterns are excluded if they have the same line count:
$lineCounts =@{}
ForEach ($parsedDocument in$parsedDocuments)
{
   $lineCounts[$parsedDocument.psbase.keys.count]++
}

if($lineCounts.Count-gt 1)
{
   Write-Host"Line counts are different"
   $documentCount =0;
   ForEach ($inputDocument in$inputDocuments)
    {
       Write-Host"Document ["$inputDocument "] has a count of: "$parsedDocuments[$documentCount].Count
       $documentCount++
   }
}

# Having agreed that they all have the same line count then go through each line
# and then compare:
# file 1 line 1 with file 2 line 1
# file 2 line 1 with file 3 line 1
# file 3 line 1 with file 4 line 1
# file 4 line 1 with file 5 line 1
# file 1 line 2 with file 2 line 2
# ....
$agreedLineCount =$parsedDocuments[0].Count
for($index=0;$index-lt $agreedLineCount;$index++)
{
   for($innerIndex =0;$innerIndex -lt $parsedDocuments.Length-1;$innerIndex++)
    {
       if($parsedDocuments[$innerIndex][$index]-cne $parsedDocuments[$innerIndex +1][$index])
        {
           Write-Host"Compared Document ["$inputDocuments[$innerIndex]"] Line Number ["($index+1)"]:"$parsedDocuments[$innerIndex][$index]
           Write-Host"To Document          ["$inputDocuments[$innerIndex +1]"] Line Number ["($index+1)"]:"$parsedDocuments[$innerIndex +1][$index]
           # If the files are horrendously different (i.e. out of step by one line) then you may just want the script exit on first error
            #Exit
       }
    }
}
Write-Host Done

I had a wry smile on the way to work the other day. I was passing a crossing, the lights were changing to green. A motorbike that had been crawling past the cars had reached the front, but people were straggling across. He blipped the throttle a few times. Nice aftermarket pipes – lovely tone, but probably not road legal. Anyway, the stragglers looked across with annoyed expressions and one of them blurted a few rude words. I carried on past the junction smiling.

It wasn’t that I was enjoying those melodic pipes. Nor was it that I missed my biking days. I had insight into the situation that others may not have. I knew that the biker had slowly controlled the bike past the line of traffic. So that he could make a nice smooth move away from the lights when they turned, he had timed it nicely to be still slowly moving as he reached the front and the lights changed. Trailing the rear brake to keep it nicely controlled so the forks wouldn’t dive from using the front brakes and make him wobble. Proper forward planning and control. What he hadn’t planned for were people crossing as the lights were going green for the traffic. As a result he was nearly at a standstill when he should have been moving away. His throttle blipping was to keep the bike balanced for a little longer so he did not have to put his feet down and for it to end up being a clumsy affair. Blipping the throttle gives the motorbike a little bit of angular momentum which stops the bike toppling over so readily – just enough to let the stragglers to clear the way. You know the trick with the big spinning disk in a briefcase that people struggle to turn? Or the plain spinning top that only falls over when it loses enough of its angular momentum.

So where the guilty stragglers saw an act of aggression I saw an act of very fine low speed handling and forward planning – hence my smile.

I saw parallels with consulting and presales. The frustrating scenarios where your skill and experience are misunderstood by clients who sometimes see time, budget and resources as excessive. Sometimes all you need is a bit of time to explain the low speed riding, forward planning and angular momentum so they can see it for the very desirable excellence and not an act of aggression, or in consulting terms: greedy profiteering. Sometimes you don’t get that chance and the client selects a supplier who doesn’t either and you just have to keep walking. Sometimes that is my job – to help my future clients really understand how we couple innovation with the rhythm and quality of manufacturing whilst building their awareness of the risks and complexity where it exists. All of this we do so that we can engage with a complete understanding – eyes wide open. Not just a proposal to win the work. A proposal to work together with understanding and transparency and empowered to succeed.

I should have mentioned it earlier, but the Microsoft offerings are based around Windows Server 2003 R2 and SQL Server 2005. I wonder why this is not Windows Server 2008 and SQL Server 2008? Were Microsoft unwilling? Did it take a long time to certify the Amazon Machine Images and the 2008 editions are on the way?

James Simmonds mentioned to me earlier that he is using GoGrid. Looks like a good offering for Windows Server 2008 and SQL Server 2005. They are still in Beta but they are promising 100% uptime and 10,000% Guaranteed SLA... They are also showing some GoGrid vs Amazon EC2 comparisons.

I'd like to correct myself too: Amazon's cloud offering is not just on-premise software. Clearly Simple Storage Service, Simple Queue Services and SimpleDB are offering more of a pure cloud platform approach as opposed to the hosted image approach. Both will have a role to play.

The rate at which .Net advances and improves is fantastic. Everything from LINQ to ASP.Net MVC via F# and parallel programming advances. The roadmap for on-premise and cloud computing shows that the future will be far from dull. Alongside the platform, the core Microsoft server products, such as Windows and SQL Server, are also advancing very favourably. Beyond Microsoft we are also getting ever more fabulous tools and frameworks ranging from ReSharper, Inversion of Control and Aspect Oriented Frameworks to Mocking and Test Frameworks. Around all of this, maturity is growing in Test Driven Development, Continuous Integration, Domain Driven Design and a whole range of Agile delivery methods. There is a growing reality of custom building solutions with repeatable success, considerable flexibility and quality that exactly meet the needs. Good times indeed.

What's my point? With such continuous and powerful advances being made I think it is time to re-evaluate many of the Build vs Buy decisions made a few years ago and maybe reset some of our defaults. Now I am not saying that something so radical has happened that the pendulum has decisively swung towards Build. However, I do think it has moved in this direction and I am expecting this to bring pressure on Product vendors to respond. That goes for Microsoft too who are ironically instrumental in handing the builders this power. You may argue that this power is also available to the product vendors, but too often I don't see that materialising. Maybe this is just the lag between harnessing the power and shipping products. That's me being generous.

No longer can products rely on (or even hide behind) arguments such as vendor support, upgrades and a resource pool of trained professionals. More than ever the products are lagging much further behind the technology curve, don't deliver exactly what you want and often represent significant compromise. Where the product contributes to the market differentiation of your business proposition it has to be super compelling and leading edge.

For example, some of these may resonate:

• How long do you have to wait for a product to take advantage of SQL Server 2008  - not just "supported on" or "compatible with", but actually exploit it?
• How long before the product adopts an architecture that better reflects how you want to deploy it in a Virtualised data centre - and changes its licensing to make sense?
• How long before it recognises that at scale might mean a large cluster of commodity hardware - e.g. a web farm of 50 pizza boxes each with their own local web and instance of a federated and co-operating database?
• How long before the product caters for and exploits the emerging and different Cloud computing platforms?
• How long before it truly exploits multi-core developments and has parallelism built right into its fabric as opposed to just using ubiquitous multiple cores as a means to extract more licensing?
• How long before the product is architected and licensed to match your increasing need to deploy for high levels of availability and business continuity? This is a regular expectation not an extraordinary demand.

In summary: Development platforms, methodologies and tooling is aggressively getting better and looks set to continue. This is certainly shifting the balance of power in the Build vs Buy argument towards Build. This should put pressure on product vendors to demonstrate clear advantages ("value-add") and more aggressive roadmaps; they have no excuse not to because they should be harnessing the same power! The Build vs Buy balance of power should remain mostly in equilibrium except during periods of arbitrage during the time lag when advances in the core technologies are harnessed by vendors. The ideal is to spot arbitrage and exploit it, or mitigate it. Right now, builders have the opportunity to make market share whilst vendors have the opportunity to leap frog competitors whilst ensuring they invest so as not to lose market share to builders!

N.B. Taking true advantage of these advances puts more emphasis on smart, skilled and experienced people.

I know. I ramble.

Looking at some of the latest Smart/PDA phones they have pretty reasonable processors, fairly significant amounts of memory, WiFi, 3G, Bluetooth, GPS, VGA screens, audio, video, voice, camera etc.

Do I really need my laptop anymore?

Most development work on most of our projects are performed using Virtual Machines running on VMWare or Hyper-V clusters. I just RDP (Remote Desktop) to them. A large amount of applications are web based applications - even the mighty Outlook/Exchange. Word, Excel, PowerPoint - that's a bit sticky, but if Google have their way most of that stuff too will be web based (even though that doesn't escape the need for reasonable local compute resources).

Assuming that the mobile device has got enough "grunt" to run those applications, then all it really needs is a nice big screen, ergonomic keyboard and mouse. We can't be far away from docking our mobiles on arrival in the offices, just like you might do with your laptop. If I really need a laptop form factor then surely it can't be a leap to design a laptop that just hosts the docking mobile. I can already see the iPhone sliding into a very slight Mac, or a HTC into a Dell. This host could provide additional battery power to cover the large bright screen and extended use running applications at higher clock speeds.

In the short term it won't satisfy the power users, but there is a large majority for whom that would work very well. Of course, when you couple this with Cloud Computing for data storage and application virtualisation it could all be very easy. I should just be able to walk around with my second brain - docking it to extend/enhance its capabilities.

Mobiles will become smarter at detecting their context and adapting to exploit it. In mobile mode it behaves as you'd expect, and when docked it will step the processor speed up, switch resolution and prioritise network usage towards a fixed local network / WiFi over 3G etc.

Device 0. It will shrink and shrink. Soon it will just be a chip in a key fob. I could insert Device 0 into a mobile phone style device giving it networking, a display and keyboard which I could further dock in a laptop or just slap on top of a Surface Computer.

Eventually, embedded in my person, Device 0 will wirelessly detect nearby resources: adopting and adapting to them them. I walk up to a Microsoft Surface and I am off... If you take this to the extreme, Device 0 is just my secure identity. The environment will provide all the resources and the cloud will extend this.

So whilst lots of people have been marvelling at how snappy Chrome is, some people have been looking at how to snap it: http://news.zdnet.co.uk/internet/0,1000000097,39485521,00.htm

Buffer overflows and carpet-bomb vulnerabilities it would seem. It is good to see that the industry has become more and more responsible at establishing security as a first class development priority. Here at Conchango we try to make it everyone's concern to worry about Performance, Availability, Security and many other non-functional requirements. However we also try and create Champions of each area within each project: specialists who advocate, review and spread awareness to push the bar higher and higher.