CHM Confusion

Posted June 25, 2009 by jeffreymuir
Categories: Windows XP

Tags: ,

Recently, I downloaded the Sysprep package from Microsoft for XP SP3.  It does not really matter why.  The package was expanded and the contents explored.  However, what happened next was unexpected.  See the screen capture below:

AddressNotValid“The address is not valid” !  How baffling is that?  Not only is it not using the Internet to get the content, there is no context information describing how this happened.  My first assumption was that I did not have the same version as the content.  This turned out to be untrue.

The truth is that Windows is blocking the content since it came from another computer.  If you look at the properties of the CHM file, it will show ‘Unblock’ as an option.  Select Unblock and the problem goes away the next time you run the CHM.

If you would like a more detailed explanation, check out this post.

Knowing What Matters

Posted May 26, 2009 by jeffreymuir
Categories: Angst

Tags:

There is nothing more important.  More important than what?  What current preoccupation is that important?  Well, it seems that important so therefore it is.

It’s a judgment call,  and clearly not all the facts are known.

Largely, the computer industry is driven from very important factors.  Much like life, there is plenty of activity both on the development and consumption.  The desire for more is always there.  The hunger for bigger and better goes on and on.

There is clearly a parallel with how automobiles were first developed.  Initially cars were very complicated and costly.  The user had to know every control and quirk.  The industry was fairly small with not much sympathy for the amateur.  Even today, this is still mostly true.

The truth is that computers are not important.  The same is true of automobiles.  It is what these tools can accomplish for the user that brings value.  Functionally, different cars only add value based on what the drivers can derive as a benefit.  

What I am getting at is that the computer experience needs to be much more transparent.  Sitting at a monitor with keyboard and mouse is not conducive to being easy.  The hardware needs to blend in with the environment to the point that the user/consumer does not even have to think about it.  This is the mantra of ubiquitous computing.  The difficult aspect is thinking outside the range of current thinking.

I was talking with my Dad over the weekend and we started talking about airplanes.  In the 60’s to 80’s, he worked as a pilot and navigator.  He pointed out that modern control systems on planes make it very difficult for a pilot to override potentially very dangerous automated decisions.  We talked about centralizing the power in the computers, it actually takes away from the experience and thinking of pilots.  From talking about this, it became clear to me that pilots should see the plane as an extension of themselves.  The computers should be used like how the brain controls the body.  The brain is the pilot and the body is the plane.  Ideally, this would be true except for cases for when the pilot cannot process the information fast enough.  Dad mentioned that planes have an automated system for landing.  It is well known and a perfect application for planes since there is actually more risk having the pilot do it.  He explained that a pilot could easily cause a “Dutch roll” in specific situations. If bad enough, this condition can be catastropic.

This comes back to an interesting idea.  Since our computers are still very dumb, it is unwise to put too much faith in them in unknown situations.  The lack of intelligence is often forgotten due to the speed of how computers figure out known problems.  It is fine for it to focus on something that can be digitized and programmed, but completely helpless with sketchy data and an unknown state.  Most faults in computer systems can either be tracked to hardware failures or software that could not recover from an unknown state.  Lately I would tend to think that most problems are in software.  It is very hard to write software that will work in all cases forever and ever.  Things change.  

So, this brings us back to what matters.  First of all, we should not put too much trust in our existing frameworks to carry us forward to the more casual computing model.  The hidden message is that basing computers solely on digital on/off switches limits their abilities considerably.  By now, we should be looking more seriously at technologies that better duplicate intelligence.  Perhaps the most revolutionary idea is that it is okay not to know things.  Much like life, we have to accept that we don’t know everything and that the computer should be allowed to learn.  This puts the computer more in the category of having a real brain.  Obviously a computer also needs to ability to link multiple locations together (or unlink) so that it can more easily find connections.  This should be done more like our neural networks and made to accept unknown states.

The best analogy is this.  You are walking down the street and suddenly something amazing happens.  For whatever reason, gravity no longer works.  You have not been programmed :) to handle this situation but you quickly try to find an idea that will help.  If you were a robot, there is a perfect chance that you were never programmed to handle this.  So, either your software faults or you just keep on doing what you were doing.

So, what would happen if gravity just stopped?  I would guess that you’d be thrown (slowly?) off the earth based on inertia and the earth’s rotation.  I don’t know.  The point is that if it did happen, at least I would be trying something.  At the very best, it is clear that I should not fault.   Even if I did fault (pass out), most likely I would reset just fine (perhaps floating off to space).

I like the idea that people usually don’t fault.  It implies that we are much too accepting of existing models and hardware.

Please excuse the tangents.  It’s hard to think clearly due to my fuzzy programming :) .

What really matters is that our faith should be shaken to usher in something new.  In fact, given the success of the web, we have largely solved the act of exchanging information.  What we have missed is realizing that many our designs are based on 1960’s (or even earlier) thinking.  

We’ve come a long way.  We still have a long ways to go.  A key goal is removing the importance of the computer in how separate it is from everthing else around us.  Things should be more specialized, simple, and transparent.  It is a process that should be much more evolutionary than it currently is.  Competing models should be allowed to win and lose based on what the environment allows.

Latest Citrix Receiver for iPhone video

Posted May 6, 2009 by jeffreymuir
Categories: Uncategorized

Tags: ,

Registry Details from Microsoft

Posted April 16, 2009 by jeffreymuir
Categories: Registry

Microsoft obviously does not want to publish certain things even though it has published a number of other things (e.g. the VHD Spec).  One of those things is the format of the registry files.  However, they have taken the time to publish what they are willing to share.  It would be worthy of reading for anyone that has not tried to look under the covers yet.

You can find the page at the Microsoft support site:

http://support.microsoft.com/kb/256986/

Citrix eDocs – online documentation

Posted March 31, 2009 by jeffreymuir
Categories: Citrix Documentation

This one is just for reference.  Citrix has published a much more interactive model for finding documentation.  On the support site is a web-hosted documentation system.

Navigation is much easier and it looks like all the products are included.  It should be easier than having to download pieces or looking at printed copies.  It even supports searching.

Fast Creation for Fixed Size VHD

Posted March 26, 2009 by jeffreymuir
Categories: VHD

Tags: ,

Search, and you shall find.  One of the many problems of dealing with VHDs is that they can take ages to create.  More specificly, the fixed VHDs can be very slow.  This is due to clearing the entire VHD with zeroes.  Creating any file that is gigabytes long is bound to be painful.

The Virtual PC Guy (Ben Armstrong from Microsoft) has come up with a solution.  It entails not zeroing out the file and creating the VHD footer at the end.  Very fast and just what most people want.  The only concern is security related to the VHD claiming deleted data since it was not cleared.  For most people this would not be a major concern under certain conditions (like a new disk).  However, this sounds like more a file system problem.  When files are deleted, they should be cleared then.  There might even be a NTFS option to do this.  Let me know, please?

Virtual PC Guy has also been nice enough to provide the binary and source for his tool.  This is a very kind gesture and I say thanks.

VHD Snapshots Revealed

Posted March 26, 2009 by jeffreymuir
Categories: VHD

Tags: ,

Microsoft produced a series of videos about Hyper-V last year from the Program Managers.  Based on recent investigations, I found a good explanation of how snapshotting works.  The VHD snapshotting video is a bit casual but captures the essence of the engineering design.  

The implementation does seem a bit rough in places compared to competing products.  Persistence will pay off.

My overall biggest concern is that the snapshotting mechanism should have built into the VHD spec.  Currently the implementation is expressed as code that manipulates VHDs for the purpose of snapshots.  The difference is subtle but enough to make this a Hyper-V only way of looking at things.  Unfortunately this will lead to other vendors to consider doing their own snapshotting technology around the weakness of the native VHD format.

VHD Documentation for Windows 7

Posted March 23, 2009 by jeffreymuir
Categories: VHD

If you look hard enough on the web, you are bound to find something good. It might not be what you started with but the distraction is worth it.  This time it is the official “unofficial” documentation from Microsoft for Windows 7 for VHD support.  This is key information about how to program to the VHD subsystem which is built into Windows 7.  

There is a great summary about Win7 VHD and here is the diagram from that section:

Don’t miss the actual API reference.  Key in mind that Microsoft is allowed to change the API before shipping Windows 7 but after that it is set in stone.  They have tried hard to match it up with the existing Windows API model so it should be very comfortable to most of you.

There are not that many API overall but some of them sound very promising.  For example, there are APIs related to creating new VHDs, compacting existing ones, and merging child VHDs with parents.  It also has the ability to grow VHDs apparently.

All this was brought to my attention by LeeL at work by referring me to an article about using the new VHD API with Windows 7.  This article brings it all together and shows examples of how to use the new API.  Things are moving along quickly with Windows 7 and the VHD support.  It’s good to see this much focus being put on VHDs for the sake of better management and flexibility.  The easier it is to manipulate, the easier it is to deploy and use.

ICA File Setting Reference

Posted March 18, 2009 by jeffreymuir
Categories: Citrix Client

Lately there are only posts if I find interesting information.  This time it was the rediscovery of the ICA File Setting Reference.  This guide includes the explanation of what the different fields mean.  I had forgotten how DesiredColor worked.  It was easy to see the values once found.

This is mostly good for administrators trying to debug connections or just the curious out there.

Windows Virtual Memory Explained

Posted March 12, 2009 by jeffreymuir
Categories: Microsoft

Tags: ,

Mark Russinovich certainly knows his stuff.  He has posted a blog from late last year about “Pushing the Limits of Windows: Virtual Memory“.  Again, I was searching for stuff related to pagefiles and found this highly technical information about how Windows memory works.

It is possible to figure out the best pagefile size from this article but it is more of an art than a science:

So how do you know how much commit charge your workloads require? You might have noticed in the screenshots that Windows tracks that number and Process Explorer shows it: Peak Commit Charge. To optimally size your paging file you should start all the applications you run at the same time, load typical data sets, and then note the commit charge peak (or look at this value after a period of time where you know maximum load was attained). Set the paging file minimum to be that value minus the amount of RAM in your system (if the value is negative, pick a minimum size to permit the kind of crash dump you are configured for). If you want to have some breathing room for potentially large commit demands, set the maximum to double that number.

You will need to understand the basics of virtual memory and commit limit before it will start to make sense.  In general it helps to overestimate but not necessarily too much.  As memory grows to be several GB, it make good sense to not use the old formulas and instead focus on what would really be useful.  Otherwise you will end up wasting GB of space on your disk for a pagefile that does not need to be that big.