From the report:
Ironically, we are headed up down the same self-destructive road for other kinds of traditional media,as good. Five years into the video-over-the-Internet revolution, we have got word two things. For the first time; consumers won”t pay for content on the web, so it will have to be ad supported. And second; it won”t be ad supported.

In the cable TV network world, half of all revenues come from affiliate (carriage) fees paid by the Comcasts and
DirecTVs of the world. The other half comes from promoting. But in the TV world, a distinctive half hour show bears out an ad load of about 8 minutes.

On the web, other evidence intimates that consumers will tune up out – click off – if they are haled to see more than 30 seconds or indeed of publicising up front, and peradventure another 90 seconds of advertising over the next thirty minutes. Hulu.com, for example, which has already been lionized by many as the future of TV, dishs two minutes of advertising for every 22 minutes of programming(i.

e. the programming duration of a distinctive half hour show from television). Arrogating selfsame CPMs for web video and TV, and after accounting for turned a loss affiliate fees, a 30 narrow program on the web with two minutes of advertising paies around 1/8th as much revenue per viewer.

Are contented producers cooked to shrink production costs…by 88%?

In fact, the factual economics of web-founded video are far, far forged than this. Our 88% decline neglects the vitriolic impact of à la carte on traditional video economics. In the public debate in Washington, the phrase à la carte refers to the idea that a few firm networks require the carriage of a host of unaccented ones, in effect subsidise a much bigger family of channels.(From MC: This is something HDNet vehemently defends and is working towards terminating) But there’s a much more of import aspect of web-based àla carte that is seldom mentioned-that is, the “à la carting” of the few betterest shows from the rest of the day’s schedule. Or even uncollectible, of the betterest few moments (news stories?) from the rest of the show. On the web, following SportsCenter not but fleeces ESPN of its ability to carry through carriage fees for ESPN Classical and ESPN U (and SoapNet and Toon Disney), it as well, and much more significantly, soaks ESPN of its ability to expend SportsCenter to underpin the economics of the rest of the 24-hour ESPN schedule. And keeping an eye on simply the betterest 30 seconds of SportsCenter fleeces ESPN of its ability to sustain the economics of… good, you catch the idea. Awaiting a few ad sustained shortclips on the web to substitute for the affiliate fee revenues lost by multiple networks 24 hours a day is lunacy. “

Bully job Craig.

The concept he delineates as the “ala carting” of the betterest from the rest is the web video consumers favourite feature, but it’s as well the largest risk to professional video content producers all over. On the Internet, the producers of the most democratic content don’t have the promotional platforms that traditional media does. There are no lead ins for Internet shows up. So there is 100 pct uncertainty as to how many people will take in any paid video. For those videos that do turn democratic, a good deal of the popularity is viral, confining the producers ability to monetise the escalation in popularity.

The Darwinian response to this problem has been to serialise shows. The hope is that if a viewer cared a show, they will come backward for more. Which of course signifies they are simulating traditional TV’s approach to content presentation and engrossing all of the same problems. The changeless need to brush up a show is not simply hard, its expensive. The invariant need to further the show to stand up out in an ala carte universe of an limitless number of shows is still more hard than it is expensive.

Indeed where does this leave behind main video content on the Internet ? The right way in the hands of Google and Youtube and blackened and white-hot hat SEOs.

The ala carting of video on the net will do good those who enable the search for content and can monetise that search.

The economics of holding content will storm severally brought forth Internet content to be dumbed down to levels that make a stark match for Youtube. There will be SEOs that follow up with arbitrage solutions that will take traffic to parked videos. Contented creators will partner with SEOs and make budgets that think over the CPMs they can realize in and around the video hosted on Youtube against the costs of the SEO geting traffic to the video. SEO support will be the only even marginally efficient way to make baseline traffic to a video/show.

Who could have infered that making financially succesful video on the net would ask the same commercializing skills as laboring traffic to parked domains ?

Content created by and for TV networks will have to create some of import decisions. Why wouldn’t advertisers desire to be one of only 2 minutes of ads in a 30 narrow TV picture instead than one of 8 mins of ads on traditional TV ? Will they compensate correspondingly bigger CPMs to be on-line ?

Are TV networks creating a vast mistake by laying their current TV schedules online for spare ? If a welled out TV depict merely has 2 mins of commercials, will that take some viewers to choose catching online ? Will it storm networks to shrink their TV usher ad load ? If thus, by how much ? Specially if and when over the top video enables Internet video to be laid out right on TVs. Will shows up be haled to present dissimilar versions of shows, say with unlike ratings as a means of differentiating TV from welled out shows ? The R shoped version of Friday Night Lights online and the PG version on TV ?

Bottom line is that something has let to present. Business as common is not becoming to hack it. The question is whether the dollars the large TV and media companies are making online from the streaming of their current TV lineups are sustainable incremental dollars ? Or is pullulating the video a collateralized video obligation ? The video equivalent of the collateralized debt behind the sub premier mess. Money that fronts sound while its making out in, but could lead to far, far large problems ?

Permalink  | Email this  | Linking Blogs  | Comments

Craftsman Style Architecture Doing A Comeback
Quick attempt at a formalizing roman numeric parser… Lots of gotchas.

Today is my 40^th birthday.  Like most other days, I started by taking the air the dog and doing a To-Do list.  Still, today’s list has a particular item:

• Resolve whether to have a mid-life crisis or not.

I’ll concede I am not all thrilled about being 40.  It doesn’t appear that long ago that 40 appeared far aside.  Nowadays that it’s hither, I see that it’s not what I required.  I guessed my life at 40 would be dissimilar.

Many who cognise me would affirm that I have nothing to sound off roughly.  And they would be right.  My life has been filled with blessings of all kinds, for which I am truly grateful.  I am a written author.  Most would see me financially successful.  I am in a career where I love my work.

But all the same…

As the honest-to-goodness supposing moves, nobody lies on their deathbed liking they had passed more time at the office.

Like most everybody else, when I was 30 I bet in front ten years and shaped a picture in my mind.  My life today doesn’t jibe that picture very easily.  Examples:

• I thought by nowadays I would be more substantial in the quality of my relationships with my loved ones and in the practice of my faith.

• I thought by nowadays I would be a better guitar player.
• There’s a mussy pile in my study that has been in that location for ten years.  (Yes, we went six years ago.  The heap went besides.)  I opined it would be stript up by at present.
• I e’er taken over that by 40 I would have picked up to work on a regular basis and terminate feeding junk food.

I move could on.  And on.  But you catch the idea.

I am allured to entertain my regrets, the places where I had a untimely turn, the places where I would have done a saucy choice if I cognised so what I cognise at present.

But this hale line of thinking doesn’t seem at all contributive to well genial health, indeed today I will prefer to focus on two things which appear more constructive:

1.  Tapestry

One of my favourite Star Trek episodes is called up Tapestry.  It is the story of someone consecrated a chance to re-experience a polar moment in his youth so that he can keep off doing the inexpedient choice he did the first time.  But it sprains out that his foolhardy moment was a decisive ingredient in his late successes.

Today I prompt myself that there are no more do-overs, and I’m not sure I would desire one anyhow.  For every mistake I have done, there were disconfirming consequences and convinced lessons.  I can’t require to keep off the former and maintain the latter.  They descend in concert as an inseparable package.

2.  Life Calculus.

Backward in 2003 I indited an article sent for Career Calculus.  In a nutshell, it alleges that at any contributed moment in your career, what you cognize is far less authoritative than whether you are geting a line.

Today I cue myself that the same principle applies in life.  I am convinced in my first derivative.  Whatever I am today, I intend I will be a best person tomorrow.

Indeed if I’m withal blogging when I’m 50, I ask I will be capable to cover progress on some of the items remarked supra.

And simply to be unmortgaged, if that heap of junk on the floor of my study is however in that respect, it will be bigger than it is at present, and I contrive to cover that as progress. 

Relating Posts:
A sited lambda calculus
AppDomains (“application domains”)
Residential Veridical Estate Appraiser Secrets – FHA Today Taking Line Applications For Appraisers

• Grease one’s palms a domain name and take up hosting in two places. Project Distributor.com should be up fairly before long to company MarkItUp.ASPXConnection.com
• Have people host their ain versions of the application. And that implies a large source release is in the future. At this juncture risk fragmentation.
• Design out fragmentation with a series of cunning features that will get everyone desire to employ the application at hand.

I’m hither to talk about the last two, since Darren already corrupted some extra hosting for us. The concept will be to free a fairly static version of the application so that groups can host tools, code snippets and other source/binary releases for their teams to partake in. The application is very lightweight and well-heeled to set-up, so it won”t require a bunch of hand holding and configuration to get up and running initially. From our standpoint we resolve a number of issues at this juncture. The most obvious problem is what we separate the Lutz Roeder use case..NET Reflector is the central type of application we’500 love to catch hosted because it makes believe it a bit well-fixed to find oneself, not that Google does a tough job, we’d simply like to get a bunch of tools in one place, with some features for feedback, novel releases, and some nerveless client tools for printing.

At present, Lutz would set up his application up and he’d walloped our bandwidth. He is the premier example of someone that should be hosting their ain tools, but peradventure applying our interface. He doesn’t have to, we haven’t even asked him yet in fact, but if he decides to do so, then all the better for the web application moving forward. Users such as Lutz belike desire a sure level of control over their ain sites as good in terms of posting and commanding access. This will simply come from hosting the application yourself (and perhaps some other features we’ll run across later).

From a security standpoint many teams will too desire to host their ain servers. In this manner they catch control over the hardware their sources and binaries are stacked away on. They can take tools up to any maximal (rather of our levyed limits) and leave limitless download bandwidth if they take. Or they can get hold of advantage of our gating mechanisms to get sure their server doesn’t catch overloaded with downloads and open up their tools up to the public.

The only major problem from this source release is that the initial problem we were proving to lick, advertising the visibility of tools, sets about to fret. You witness, the more sites that host their ain tools the harder it is to witness the right-hand site with the right-hand tools. We are stressing to resolve this in a number of ways. The first is taking into account users of a site to stash away bookmarks to other projects and outside resources. This is exclusively a irregular fix, because it stock-still doesn’t permit a mass search and categorization infrastructure required to in truth push the visibility of the tools being hosted. We have to occur up with a solution that takes all of the sites, but we don”t want to create just another portal or gateway site. That is drilling. Nowadays you have the background, thusly how will we lick the fragmentation issue?

Planing off Fragmentation
I won”t lie to you, I’ve implemented this model several times, but have never had a project that was capable of really showing off the feature set we are about to talk about. The concept is to commix all of the sites, by leaving them to easy handle views of data from all of the sites aggregated. Each site possesss their ain content, keeps their ain users, but in turn peers with other sites to find extra content.

Web services allow for a double feature kicked in this model. At the current level they permit us to yield really heavy client-side tools for pulling off, intimately, your tools! We have a drop-client target right at present so you can trail and drop newfangled releases to subsisting projects in just now a few seconds. Some raw tools for working with build systems to push the source code up to the server are in the works. We natively integrate with your RSS reader and will have our ain watchful services in the drop client simply in case you don”t have one. There aren’t any search or local hoarding features, but those are as well planned for the drop client so you can background download raw releases, simply like Windows Update.

That doesn’t work out fragmentation though, that simply prepares me realise how much work I have bequeathed to do. The second feature of web services lies in the ability for each site to aggregative data from the many other sites that are out at that place hosting the application. Think of, everything we give uncommitted at the service layer can likewise at present be remoted. The more stashing we put into the data layer, the more performant the full process will be, and we can yet tune up the caching depending on whether the data layer is mixing off-site contents or database contents.

Peer Sites
I’m surely there is another name out at that place somewhere, but for the past 2 years I’ve sent for these peer sites. Each instance of the project distributor will have a number of options allowing imparting peers that will be combined and added to the local collection while users cross the site. The first step is to start out the peer sites running in a read-only mode. And typeset up some really with child options so the intact process can be ensured. This resolves a number of use case scenarios for us including the surveiling.

• Fragmentation can be mitigated through right configuration. If everyone combines 5 or 6 sites into their peers, and then we have a vast network at present of interlinked peers and users can cull and select which one they use for purposes of looking for the tool network.
• Peer connections are unidirectional or bidirectional. Access is configurable. Teams can admit tools from international sites while saving their ain tools completely secret. They can exist behind a DMZ or a secret network.
• Users can host their ain personal tool sites in the same manner as the team sites. They can configure statically which contrives to create uncommitted yet. In this way you can establish a collection of personal tools that you bang, and have the up-to-the-minutest information mechanically update on your machine for your perusal.

Peer sites figure out plenty of visibility issues, but that is pretty much all they solve for at present. We nonetheless desire to enable all of the features uncommitted to the client tools. After all, the web service methods and proxy infrastructure is in place to do so much more.

Master Sites
Well, we desire to resolve another problem. That is where you cut your data. A master site is where the users, groups, projects, etc… are all hosted, but thankfully, you’ll be capable to log in through any site (accepting it is peered with your master site) and and so edit out your ain projects and such. This is a outside master context and is really one of the nerveless features associated with the peering functionality of project distributor. We’ll be fully untroubled in our login and credentials region, but regrettably we’ll stock-still be transplanting data in unresolved text in the little term. Mayhap we’ll pay off that with enough push backward.

Clone Rides
A clone site is where we indue a site to act on behalf of a master site. For me, my local project distributor is presently cloned to the independent project distributor site. What does this mean? Right nowadays it haves in mind I grow all of the data from PD, and that users who desire my site can log-in to their project distributor accounts and cross edit data. Pretty skillful if you enquire me. It fundamentally implies you can full host a project distributor installation and ne’er, of all time have to instal a database server. Users can simply follow up on behalf of a outside server.

Configuration
This isn’t a tiptop recyclable model like some of those you read some in the democratic software architecture books, and it in all likelihood accounts for why master/peer/clone sites don”t exist very often. The considerations for every option are to a great extent customized to the problem being worked, and I’m certain we’ll be producing modifications or updating the configuration context for a while. Right at present you can severally configure your basal server type, whether master or clone, whether or not users can employ you for a pass-through authentication and edit server, whether or not web services are enabled so peers can enable unidirectional only communications, preparing up asymmetrical security credentials. Man, you mention it and it is in there

For the peer section we have total and selective modes. A wide-cut peer draws all of the data on the distant peer topically for display (in a delay hiving up manner, exactly like you’d require, unless you planted up a scheduled pull which is too potential). I ask most people to configure replete peers because they truly are really loose to set up up and keep. A selective peer is where you particularise the groups/projects that you desire to exhibit. This is best for a user arranging up their ain personal toolbox who requires to take a couple of items from many dissimilar peers.

We have an extensively thorough configuration module already and we’ll be unceasingly imparting more to it. The concept is to easy change your toolbox to your ain designs without having to extend to the code. If we haven”t given you enough options to satisfy your need then we’ll have to make something up, because I’m just about running out

These are the basics of the model ideas I have for project distributor. That doesn’t think Darren doesn’t have other with child ideas passing off as intimately. He has some pretty extended UI enhancements, but I’ll get him talk about those. We yet have another product idea that is kind of a bolt-on for project distributor, but that is belike a couple of months out laying it into next year. Unluckily we have too many ideas for our ain ripe right at present. Better than not having any ideas I hazard. I’ll render to set down some code with some of the ideas supra, that way you can make a look at how the intact system is followed up. I have some diagrams as considerably, but I’m far besides fatigued right at present to supply the img tags to the HTML view.

Relating Posts:
Which Side of the Foresightful Tail Should You Initiate On?
Connect Love: 09/21/2007

Sean & Scott  [fixated link]: The example you yielded is outstanding, although I would advise something a little more robust, specifically you believably desire to take into account data to pass between the already escaping instance and the newfangled one made (this takes into account you to mobilise the command line arguments). I pent an article on this last year… however holding up data marhsalling makes believe the code much much more awful.

BTW, there were some underage bugs in the single instance logic that were fixed in next article in the series.

Relating Posts:
Crucial changes to the BASE element for IE 7
When Will Foreign Ownership of US Sports Teams Start ?
Obviate DevPath

But what about the Google Index, all the websites that are indexed by Google ? What is it deserving to be in the Google Index ? What would you, as a website owner require in order to take your site from the Google Index and no longer be uncommitted when someone does a google search ?

It should simply be a matter of dollars and cents and sense, shouldn’t it ?

How many websites would have to recuse themselves from the Google Index before Google Search was negatively touched on ?
Mahalo.com intends it demands to sustain the 25k most common search terms in order to be successful. What would encounter if MicroSoft or Yahoo or a MicroHoo attended the 5 top results for the top 25k searches and compensated them to allow the Google Index ?

A theoretic maximum of 125k sites, but with overlap, in all probability closer to 100k or less, times how much per site on average ?

The math starts out to pay back interesting. At $1,000 per site median times 100k sites, thats only when $ 1 Billion Dollars. The distribution would plain favour the bigger sites, indeed of that billion dollars, would the top 1k sites get hold of 500k each and the resting 99k parted the rest ?

Kicked in the stakes, why stop at $ 1 Billion Dollars ? Would the top 1k most inspected sites accept a coolheaded $1mm each, plus a committment from MicroSoft or Yahoo to labor traffic through their search engines to more than make up up for the turned a loss Google Traffic. After all, one time consumers realised that Google no longer had valid search results for the top 25k searchs, that traffic would most belike go to MicroSoft and Yahoo.

And why we are at it, why not ask that these 100k sites switch from Googles Publisher Network to Yahoo’s or MicroSofts ? It would start up to take in backward the $1 Billion compensated out very apace.

On top of that, in order to grease the skids even further, why not make out publicising credits to the sites that exchanged off Google ? Its delicate dollars, that would sweeten the pot and take more traffic.

IN essence, its no dissimilar that any other content aggregation play. Its paying for content. But, It would accept some heavy ones to consent it and visit if it turned. Still, without question, every search engine has some number of core sites, that when removed from its index , destabilises the value of its search.

The question is how many ? What would it bed to get down that number of sites to move around Google off and rest off, and would the traffic created as users switch from Google more than compensate for the cost ?

Or would Google know the risk and leap in and offer up more to websites to rest ?

For certain would be interesting to chance out.

Permalink  | Email this  | Linking Blogs  | Comments

Relating Posts:
Reserve judgement lest thou be judged too…
Connect Love: 09/21/2007
Online Marketing in Veridical Estate – Firm Start to Stagnation
Sometimes, it’s the small things..

Also see: Video games

Also see: JSR-294 Superpackages

Tagspace * is a social bookmarking service for software professionals** that encourages sound sleep and sweet dreams by enabling you to be better informed, better connected, and more productive. The more you use Tagspace, the more you’ll wonder how you survived for so long in the cramped quarters of your Web browser’s Favorites folder.

WARNING: TAGSPACE IS ADDICTIVE. REPEATED USAGE MAY CAUSE INCREASED PRODUCTIVITY.
*Tagspace has been shown to be effective in helping to prevent and reduce memory decay.
**No animals or software engineers were harmed in the making or testing of Tagspace.

For more information about Tagspace, see:

Screencast (direct stream): intro2tagspace.wvx Screencast (on MSN Soapbox): intro2tagspace.wmv Text Overview: Tagspace Beta Refresh Overview
Product Roadmap: Microsoft.Community Today and Tomorrow   (…because this is just the beginning.)
Tagspace: In the News
Subscribe: RSS

An
AppDomain is a light-weight process. 
Well, if you actually measure the costs associated with an AppDomain –
especially the first one you create, which has some additional costs that are
amortized over all subsequent ones – then “light-weight” deserves some
explanation:

A Win32
process is heavy-weight compared to a Unix process.  A Win32 thread is heavy-weight compared
to a Unix thread, particularly if you are using a non-kernel user threads
package on Unix.  A good design for
Windows will create and destroy processes at a low rate, will have a small
number of processes, and will have a small number of threads in each
process.

Towards
the end of V1, we did some capacity testing using ASP.NET.  At that time, we were able to squeeze
1000 very simple applications /
AppDomains into a single worker process. 
Presumably that process would have had 50-100 threads active in it, even
under heavy load.  If we had used OS
processes for each application, we would have 1000 CLRs with 1000 GC heaps.  More disturbing, we would have at least
10,000 threads.  This would reserve
10 GB of VM just for their default 1 MB stacks (though it would only commit a
fraction of that memory).  All those
threads would completely swamp the OS scheduler.

Also see: Infrequent blogging

Also see: We Live in an “Open Book” World, the Lie of Information Overload

Also see: The PDC and Application Compatibility, but still no Hosting

Also, if
you execute a lot of processes, it’s key that those processes are filled with
shared pages (for example, the same code loaded at the same preferred addresses)
rather than private pages (like dynamically allocated data).  Unfortunately, JITted code results in
private pages.  Our NGEN mechanism
can be used to create pre-JITted images that can be shared across
processes.  But NGEN is not a
panacea: NGEN images must be explicitly generated; if their dependencies change
through versioning, modifications to security policy, etc., then the loader will
reject the images as invalid and quietly fall back on JITting; NGEN images
improve load time, but they actually insert a small steady-state cost to some
operations, due to indirections; and NGEN can do a worse job of achieving
locality than JITting and dynamically loading types (at least in the absence of
a training scenario).

Over
time, I think you’ll see NGEN address many of these limitations and become a
core part of our execution story.

Also see: IDE Day in Genoa, Italy

Also see: Why should I be optimistic about Trolltech and Nokia?

Also see: What Are You Destined to Be ?

Also see: 2,433 Unread Emails, I feel your pain..

Of
course, I wouldn’t recommend that you actually run a process with 1000
AppDomains either.  For example,
address space is an increasingly scarce resource – particularly on servers.  The version of the CLR we just shipped
now supports 3 GB of user address space, rather than the 2 GB that is normally
available.  (You need to boot the
system for this, and sacrifice OS buffer space, so don’t do it unless you really
need it).  64-bit systems, including
a 64-bit CLR, cannot come soon enough for certain scenarios.

Compared
to our goals, it still takes too long to create and destroy AppDomains.  The VM and working set hits are too
high.  And the cost of crossing an
AppDomain boundary is embarrassing. 
But the general architecture is sound and you should see improvements in
all these areas in future releases.

Also see: SourceGear at SD West next week

Also see: Determining Whether a File Is an Assembly

Also see: Avoid DevPath

Also see: Quick attempt at a validating roman numeral parser… Lots of gotchas.

Also see: The influence of style upon methodology…

Also see: Infrequent blogging

Also see: When Will Foreign Ownership of US Sports Teams Start ?

Also see: Should “Membership Stores” Be Permitted in Redmond’s Manufacturing Park Zone?

It’s too
simplistic to say that AppDomains are just light-weight OS processes.  There is more to say in several
dimensions:

• Security
  
• Instance lifetime
  
• Type identity
  
• Domain-neutrality
  
• Per-AppDomain state like static fields
  
• Instance-agility
  
• Configuration and assembly binding
  
• Unloading and other resource management
  
• Programming model

Also see: IDE Day in Genoa, Italy

Also see: Single source code base for Silverlight and WPF solutions

Also see: Passing the Community Torch: In Search of a New Chief Executive in Redmond

Also see: From C# to Java: Part 5

Also see: The influence of style upon methodology…

Also see: Natural Sorting in C#

Also see: Load(AssemblyName)

Also see: Why Yahoo should say Yes to MicroSoft

Also see: Important changes to the BASE element for IE 7

Also see: Presentations…

Also see: UI design

Also see: Is this the best NBA season ever ?

Also see: Spring Web Flow features and feedback request

Also see: Introducing Microsoft Tagspace

Also see: My Presidential Endorsement:

Also see: Java Concurrency, another series on its issues

Also see: Help John Baez and Mike Stay!

Also see: Infrequent blogging

Also see: This Guy Proves Anyone with a Keyboard can be Stupid

Also see: The PDC and Application Compatibility, but still no Hosting

Also see: JSR-294 Superpackages

Also see: Uniqueness Typing Simplified

Also see: Blogging and Newspapers, a Lesson in How Not to Brand and Market

Also see: Infrequent blogging

Also see: Link Love: 09/21/2007

Also see: Finally, the Killer App

Also see: JSR-294 Superpackages

Also see: The 2 Technology Magazines You Should Read

Also see: Should “Membership Stores” Be Permitted in Redmond’s Manufacturing Park Zone?

Security

Code
Access Security only works within an OS process.  Threads freely call through AppDomain
boundaries, so the CLR must be able to crawl stacks across those boundaries to
evaluate permission demands.  In
fact, it can crawl compressed stacks that have been disassociated from their
threads, accurately evaluating permissions based on AppDomains that have already
been unloaded.

It’s
conceivable that one day we will have a sufficiently strong notion of
distributed trust that we can usefully propagate compressed stacks into other
processes.  However, I don’t expect
we’ll see that sort of distributed security for at least another couple of
releases.

It’s
possible to apply different security policy or different security evidence at
the granularity of an AppDomain. 
Any grants that would result based on AppDomain evidence and policy are
intersected with what would be granted by policy at other levels, like machine
or enterprise.  For example,
Internet Explorer attaches a different codebase to an AppDomain to indicate the
origin of the code that’s running in it. 
There are two ways for the host to control security at an AppDomain
granularity.  Unfortunately, both
techniques are somewhat flawed:

1)     
The host can pre-load a set of
highly-trusted assemblies into an AppDomain.  Then it can modify the security policy
to be more restrictive and start loading less-trusted application code.  The new restricted policy will only
apply to these subsequent loads. 
This approach is flawed because it forces the host to form a closure of
the initial highly-trusted set of assemblies.  Whatever technique the host uses here is
likely to be brittle, particularly in the face of versioning.  Any dependent assemblies that are
forgotten in the initial load will be limited by the restricted policy.  Furthermore, it is unnecessarily
expensive to eagerly load assemblies, just so they can escape a particular
security policy.

Also see: Finally, the Killer App

Also see: The obligatory Halo 2 partial review and thumbs up.

Also see: UI design

Also see: Single source code base for Silverlight and WPF solutions

Also see: Note to self: Blog about using Service Broker

Also see: Generics and .NET

Also see: Important changes to the BASE element for IE 7

Also see: Eriskay: a Programming Language Based on Game Semantics

Also see: 2,433 Unread Emails, I feel your pain..

Also see: Important changes to the BASE element for IE 7

2)     
The host can load the application
assemblies with extra evidence. 
When the security system evaluates the grant set for these assemblies,
this extra evidence can be considered and the application assemblies will get
reduced permissions.  This technique
allows the host to lazily load highly trusted assemblies into the same
AppDomain, since these won’t have the extra evidence attached to them.  Unfortunately, this technique also has a
rough edge.  If an application
assembly has a dependency on a second application assembly, what is going to
attach extra evidence to the 2^nd assembly?  I suppose the host could get the
1^st assembly’s dependencies and eagerly load them.  But now we are back on a plan where
transitive closures must be eagerly loaded in order to remain secure.  And, in future releases, we would like
to give each assembly a chance to run initialization code.  There’s a risk that such initialization
code might run and fault in the dependencies before the host can explicitly load
them with extra evidence.

We need
to do better here in a future release.

Until
then, code injection remains a real concern.  A host carefully prepares an AppDomain
and loads some partially trusted application code there for execution.  If the application code can inject
itself into a different AppDomain (especially the default AppDomain, which is
presumably where the fully trusted host is executing), then it can escape the
policy and extra evidence that is constraining it.  This is one reason that we don’t provide
AppDomain enumeration services to partially trusted code.  If you can find an AppDomain, you can
perform an AppDomain.DoCallBack into it passing a delegate.  This has the effect of marshaling the
delegate into that AppDomain and then dispatching to it there.  The assemblies containing the delegate
and the target of the delegate will be created in the specified
AppDomain.

Today,
if a host exercises great care, it can use AppDomains as the basis of building a
secure environment.  In the future,
we would like to reduce the amount of care required of the host.  One obvious way to do this is to involve
the host in any assembly loads that happen in any AppDomain.  Unfortunately, that simple approach
makes it difficult to make wise decisions on loading assemblies as
domain-neutral, as we’ll see later.

Instance
Lifetime

The CLR
contains a tracing GC which can accurately, though non-deterministically, detect
whether an object is still reachable. 
It is accurate because, unlike a conservative GC, it knows how to find
all the references.  It never leaves
objects alive just because it can’t distinguish an object reference from an
integer with the same coincidental set of bits.  Our GC is non-deterministic because it
optimizes for efficient memory utilization.  It collects portions of the GC heap that
it predicts will productively return memory to the heap, and only when it thinks
the returned memory warrants the effort it will expend.

If the
GC can see an orphaned cycle where A refers to B and B refers to A (but neither
A nor B are otherwise reachable), it will collect that cycle.  However, you can create cycles that the
GC cannot trace through and which are therefore uncollectible.  A simple way to do this is to have
object A refer to object B via a GCHandle rather than a normal object
reference.  All handles are
considered part of the root-set, so B (and thus A) is never
collected.

The GC
cannot trace through unmanaged memory either.  Any cycles that involve COM objects will
be uncollectible.  It is the
application’s responsibility to explicitly break the cycle by nulling a
reference, or by calling ReleaseComObject, or by some other technique.  Of course, this is standard practice in
the COM world anyway.

Nor can
the GC trace across processes. 
Instead, Managed Remoting uses a system of leases to achieve control over
distributed lifetime.  Calls on
remote objects automatically extend the lease the client holds.  Leases can trivially be made infinite,
in which case the application is again responsible for breaking cycles so that
collection can proceed. 
Alternatively, the application can provide a sponsor which will be
notified before a remote object would be collected.  This gives the application the
opportunity to extend leases “on demand”, which reduces network
traffic.

By
default, if you don’t access a remote object for about 6 minutes, your lease
will expire and your connection to that remote object is lost.  You can try this yourself, with a remote
object in a 2^nd process. 
But listen carefully:  you
can also try it with a remote object in a 2^nd AppDomain.  If you leave your desk for a cup of tea,
your cross-AppDomain references can actually timeout and disconnect!

Perhaps
one day we will build a distributed GC that is accurate and non-deterministic
across a group of processes or even machines.  Frankly, I think it’s just as likely
that we’ll continue to rely on techniques like configurable leases for
cross-process or cross-machine lifetime management.

However,
there’s no good reason for using that same mechanism cross-AppDomain.  There’s a relatively simple way for us to
trace object references across AppDomain boundaries – even in the presence of
AppDomain unloading.  This would be
much more efficient than what we do today, and would relieve developers of a big
source of problems.

We
should fix this.

Type
Identity

Managed
objects can be marshaled across AppDomain boundaries according to one of several
different plans:

• Unmarshalable

This is the default for all types. 
If an object is not marked with the Serializable custom attribute, it
cannot be marshaled.  Any attempt to
pass such an object across an AppDomain boundary will result in an
exception.

• Marshal-by-value

This is the default for all types that are marked as Serializable, unless
they inherit from MarshalByRefObject. 
During a single marshal of a graph of objects, identity is
preserved.  But if the same object
is marshaled on two separate calls from AppDomain1 to AppDomain2, this will
result in two unrelated instances in AppDomain2.

• Marshal-by-reference

Any Serializable types that inherit from System.MarshalByRefObject will
marshal by reference.  This causes
an identity-preserving proxy to be created in the client’s AppDomain.  Most calls and any field accesses on
this proxy will remote the operation back to the server’s AppDomain.  There are a couple of calls, defined on
System.Object (like GetType), which might actually execute in the client’s
AppDomain.

• Marshal-by-bleed

Certain objects are allowed to bleed.  For the most part, this bleeding is an
optional performance optimization. 
For example, if you pass a String object as an argument on a call to a
remoted MarshalByRefObject instance, the String is likely to bleed across the
AppDomain boundary.  But if you
create a value type with an Object[] field, put that same String into the
Object[], and pass the struct, the current marshaler might not bleed your
String.  Instead, it’s likely to be
marshaled by value.

In
other cases, we absolutely require that an instance marshal by bleed.  System.Threading.Thread is a good
example of this.  The same managed
thread can freely call between AppDomains. 
Since the current marshaler cannot guarantee that an instance will always
bleed, we have made Thread unmarshalable by the marshaler for now.  Then the CLR bleeds it without using the
marshaler when you call Thread.CurrentThread.

• Identity-preserving marshal-by-value

As
we’ve seen, objects which marshal by value only preserve identity in a single
marshaling operation, like a single remoted call.  This means that, the more you call, the
more objects you create.  This is
unacceptable for certain objects, like certain instances of System.Type.  Instead, we marshal the type specifier
from one AppDomain to another, effectively do a type load in the 2^nd
AppDomain (finding any corresponding type that has already been loaded, of
course) and then treat that type as the result of the unmarshal.

• Custom marshaling

The Managed Remoting and serialization architectures are quite
flexible.  They contain sufficient
extensibility for you to define your own marshaling semantics.  Some researchers at Microsoft tried to
build a system that transparently migrated objects to whatever client process
was currently using them.  I’m not
sure how far they got.

How does
all this relate to type identity? 
Well, instances of System.Type, and the metaobjects reachable from them
like MethodInfos and PropertyInfos, can be marshaled in two different ways.  If the underlying assembly was loaded as
domain-neutral into the two AppDomains involved in a remote operation, then the
metaobjects from that assembly will be marshaled-by-bleed.  If instead the underlying assembly was
loaded per-domain, then the metaobjects from that assembly will be
identity-preserving marshaled-by-value.

Domain-neutrality

So
what’s this domain-neutral vs. per-domain distinction?  Remember when I said that a key to good
performance is to have lots of shared pages and to minimize private pages?  At the time, I was talking about sharing
pages across processes.  But the
same is true of sharing pages across AppDomains.  If all the AppDomains in a process can
use the same JITted code, MethodTables, MethodDescs and other runtime
structures, this will give us a dramatic performance boost when we create more
AppDomains in that process.

If an
assembly is loaded domain-neutral, we just mean that all these data structures
and code are available in all the different AppDomains.  If that same assembly is loaded
per-domain, we have to duplicate all those structures between
AppDomains.

In V1
and V1.1 of the CLR, we offer the following policies for determining which
assemblies should be domain-neutral:

1)     
Only share mscorlib.dll.  This choice is the default.  We must always share mscorlib, because
the operating system will only load one copy of mscorwks.dll (the CLR) into a
process.  And there are many 1:1
references backwards and forwards between mscorwks and mscorlib.  For this reason, we need to be sure
there’s only a single mscorlib.dll, shared across all the different
AppDomains.

2)     
Share all strongly-named
assemblies.  This is the choice made
by ASP.NET.  It’s a reasonable
choice for them because all ASP.NET infrastructure is strongly-named and happens
to be used in all AppDomains.  The
code from web pages is not strongly-named and tends to be used only from a
single AppDomain anyway.

3)     
Share all assemblies.  I’m not aware of any host or application
which uses this choice.

Wait a
second.  If sharing pages is such a
great idea, why isn’t everyone using “Share all assemblies”?  That’s because domain-neutral code has a
couple of drawbacks.  First and most
importantly, domain-neutral code can never be unloaded.  This is an unfortunate consequence of
our implementation, though fixing it will be quite hard.  It may be several more releases before
we even try.

A second
drawback is that domain-neutral code introduces a few inefficiencies.  Usually the working set benefits quickly
justify these inefficiencies, but there may be some scenarios (like
single-AppDomain processes!) where this isn’t true.  These inefficiencies include a 1:M
lookup on all static field accesses and some high costs associated with deciding
when to execute class constructors. 
That’s because the code is shared across all AppDomains, yet each
AppDomain needs its own copy of static fields which are initialized through its
own local execution of a.cctor method. 
You can reduce the overhead associated with.cctors (whether in
domain-neutral code or not) by marking your.cctors with tdBeforeFieldInit.  I’ve mentioned this in prior
blogs.

Finally,
in V1 & V1.1, we don’t allow you to combine NGEN with domain-neutral
code.  This may not be a concern for
you, given the other limitations associated with NGEN today.  And I’m confident that we’ll remove this
particular restriction in a future release.

Okay,
but this still sucks.  Why are these
choices so limited?  Ideally a host
would specify a set of its own assemblies and some FX assemblies for
sharing.  Since these assemblies
would be intrinsic to the operation of the host, it wouldn’t matter that they
can never unload.  Then the
application assemblies would be loaded per-domain.

We can’t
support this because, if one assembly is loaded as domain-neutral, all the other
assemblies in its binding closure must also be loaded as domain-neutral.  This requirement is trivially satisfied
by the first and third policies above. 
For the 2^nd policy, we rely on the fact that strong-named
assemblies can only early-bind to other strong-named assemblies.

If we
didn’t require an entire binding closure to be domain-neutral, then references
from a domain-neutral assembly to a per-domain assembly would require a 1:M
lookup, similar to what we do for static field accesses.  It’s easy to see how this sort of lookup
can work for static field access. 
But it’s much harder to see what kind of indirections would allow a
domain-neutral type to inherit from a per-domain one.  All the instance field offsets, base
class methods, and VTable slots would need biasing via a 1:M lookup.  Ouch.

In fact,
long term we’re not trying to find some more flexible policies for a host to
specify which assemblies can be loaded domain-neutral.  It’s evil to have knobs that an
application must set.  We really
want to reach a world where the CLR makes sensible decisions on the most
appropriate way to execute any application.  To get there, we would like to remove
the inefficiencies and differing semantics associated with domain-neutral code
and make such assemblies unloadable. 
Then we would like to train our loader to notice those AppDomains which
will necessarily make identical binding decisions (more on this later).  This will result in maximum automatic
sharing.

It’s not
yet clear whether/when we can achieve this ideal.

Per-AppDomain state like static
fields

As
stated above, domain-neutrality would ideally be a transparent optimization that
the system applies on behalf of your application.  There should be no observable semantics
associated with this decision, other than performance.

Whether
types are domain-neutral or not, each AppDomain must get its own copy of static
fields.  And a class constructor
must run in each of those AppDomains, to ensure that these static fields are
properly initialized.

Instance-agility

We just
discussed how domain-neutrality refers to assemblies and how they are shared
between AppDomains. 
Instance-agility refers to object instances and how they are allowed to
flow between AppDomains.

An agile
instance must necessarily be of a type we loaded as domain-neutral.  However, the converse is not true.  The vast majority of domain-neutral
types do not have agile instances.

If an
instance marshals-by-bleed or if it performs identity-preserving
marshal-by-value, then by definition it is agile.  The effect is the same in both cases:
it’s possible to have direct references to the same instance from multiple
AppDomains.

This is
in contrast to normal non-agile instances which are created, live and die in a
single AppDomain.  We don’t bother
to track which AppDomain these instances belong to, because we can infer
this.  If a thread is accessing an
instance, then the instance is clearly in the same AppDomain that the thread is
currently executing in.  If we find
references to an instance further back on a thread’s stack, then we can use the
AppDomain transitions which are recorded on that stack to determine the correct
AppDomain.  And – for per-domain
types – the type itself can tell us which AppDomain the instance belongs
to.

Although
we don’t normally track the AppDomain which contains an instance, there are some
exceptions.  For example, a
Finalizable object must be finalized in the AppDomain it lives in.  So when an instance is registered for
finalization, we always record the current AppDomain at that time.  And the finalizer thread(s) take care to
batch up instances in the same AppDomain to minimize transitions.

For an
instance to be agile, it must satisfy these rules:

• It must be of a type that was loaded as
  domain-neutral.  (Today, we
  restrict ourselves to types in mscorlib.dll, which is always
  domain-neutral).
  
• The type must not be unloaded until the last instance has
  died.  (Today, we never unload
  these types).
  
• Instances must not have references to any other instances
  that are not themselves agile.

Based on
these rules, it’s actually possible for the loader to identify some types as
having legally agile instances. 
System.String is a good example, because it is sealed and has no
references to other instances. 
However, this automatic detection would be inadequate for our
purposes.  We need some additional
objects like System.Threading.Thread to be agile.  Since Thread can contain references to
many objects that are clearly not agile (like managed thread local storage,
which contains arbitrary application objects), we have to be very careful
here.

In this
case, being careful means that we partition some of the Thread’s state in a
per-AppDomain manner.

If
you’ve read my earlier blogs, you know that static fields can be per-AppDomain,
per-Thread, per-Context, or per-process (RVA-based statics).  Now you know why the per-Thread and
per-Context statics are still partitioned by AppDomain.  And you understand why the per-process
statics are restricted from containing arbitrary object references.  They can only contain scalars, Strings
(agile instances!) and value types that are themselves similarly
constrained.

If
you’ve done much debugging with AppDomains and exceptions, you’ve probably
noticed that the first pass of exception handling is always terminated at an
AppDomain boundary.  It’s annoying:
if the exception goes unhandled and you take your last chance as a trap to the
debugger, you’ve lost the original context of the exception.  But now it’s clear why this
happens.  If an exception instance
isn’t agile, it must be marshaled from one AppDomain to the next as the dispatch
occurs.  (We make a special
exception for an AppDomain-agile OutOfMemoryException that we pre-create, so
that it’s available when we don’t have enough memory to make a per-AppDomain
instance).

In fact,
there’s a lot of complexity involved in ensuring that instances are only
accessible from one AppDomain, or that they follow the discipline necessary for
agility.  You may be wondering why
we care.  We care because AppDomain
isolation is a fundamental guarantee of the managed environment, on which many
other guarantees can be built.  In
this sense, it is like separate address spaces for OS processes.  Because of AppDomain isolation, we can
build certain security guarantees and we can reclaim resources correctly when
AppDomains are unloaded.

Configuration and Assembly Binding

Since
each AppDomain is expected to execute a different application, each AppDomain
can have its own private paths for binding to its assemblies, its own security
policy, and in general its own configuration.  Even worse, a host can listen to the
AssemblyResolveEvent and dynamically affect binding decisions in each
AppDomain.  And the application can
modify configuration information like the AppDomain’s private path – even as it
runs.  This sets up terrible data
races, which rely on unfortunate side effects like the degree of inlining the
JIT is performing and how lazy or aggressive the loader is in resolving
dependent assemblies.  Applications
that rely on this sort of thing are very fragile from one release of the CLR to
the next.

This
also makes it very difficult for the loader to make sensible and efficient
decisions about what assemblies can be shared.  To do a perfect job, the loader would
have to eagerly resolve entire binding closures in each AppDomain, to be sure
that those AppDomains can share a single domain-neutral assembly.

Frankly,
we gave the host and the application a lot of rope to hang themselves.  In retrospect, we screwed up.

I
suspect that in future versions we will try to dictate some reasonable
limitations on what the host and the AppDomain’s configuration can do, at least
in those cases where they want efficient and implicit sharing of domain-neutral
assemblies to happen.

Unloading

A host or
other sufficiently privileged code can explicitly unload any AppDomain it has a
reference to, except for the default AppDomain which is not unloadable.  The default AppDomain is the one that is
created on your behalf when the process starts.  This is the AppDomain a host typically
chooses for its own execution.

The
steps involved in an unload operation are generally as follows.  As in many of these blogs, I’m
describing implementation details and I’m doing so without reading any source
code.  Hopefully the reader can
distinguish the model from the implementation details to understand which parts
of the description can change arbitrarily over time.

• Since the thread that calls AppDomain.Unload may itself
  have stack in the doomed AppDomain, a special helper thread is created to
  perform the unload attempt.  This
  thread is cached, so every Unload doesn’t imply creation of a new thread.  If we had a notion of task priorities
  in our ThreadPool, we would be using a ThreadPool thread here.

• The unload thread sends a DomainUnload event to any
  interested listeners.  Nothing bad
  has happened yet, when you receive this event.

• The unload thread freezes the runtime.  This is similar to the freeze that
  happens during (portions of) a garbage collection.  It results in a barrier that prevents
  all managed execution.

• While the barrier is in place for all managed execution,
  the unload thread erects a finer-grained barrier which prevents entry into the
  doomed AppDomain.  Any attempt to
  call in will be rejected with a DomainUnloaded exception.  The unload thread also examines the
  stacks of all managed threads to decide which ones must be unwound.  Any thread with stack in the doomed
  AppDomain – even if it is currently executing in a different AppDomain – must
  be unwound.  Some threads might
  have multiple disjoint regions of stack in the doomed AppDomain.  When this is the case, we determine
  the base-most frame that must be unwound before this thread is no longer
  implicated in the doomed AppDomain.

• The unload thread unfreezes the runtime.  Of course, the finer-grained barrier
  remains in place to prevent any new threads from entering the doomed
  AppDomain.

• The unload thread goes to work on unwinding the threads
  that it has identified.  This is
  done by injecting ThreadAbortExceptions into those threads.  Today we do this in a more
  heavy-weight but more scalable fashion than by calling Thread.Abort() on each
  thread, but the effect is largely the same.  As with Thread.Abort, we are unable to
  take control of threads that are in unmanaged code.  If such threads are stubborn and never
  return to the CLR, we have no choice but to timeout the Unload attempt, undo
  our partial work, and return failure to the calling thread.  Therefore, we are careful to unwind
  the thread that called Unload only after all the others have unwound.  We want to be sure we have a thread to
  return our failure to, if a timeout occurs!

• When threads unwind with a ThreadAbortException, the Abort
  is propagated in the normal undeniable fashion.  If a thread attempts to catch such an
  exception, we automatically re-raise the exception at the end of the catch
  clause.  However, when the
  exception reaches that base-most frame we identified above, we convert the
  undeniable ThreadAbortException to a normal DomainUnloaded
  exception.

• No threads can execute in the doomed AppDomain – except for
  a Finalizer thread which is now given a special privilege.  We tell the Finalizer thread to scan
  its queue of ready-to-run finalizable objects and finalize all the ones in
  this AppDomain.  We also tell it
  to scan its queue of finalizable but still reachable objects (not ready to
  run, under normal circumstances) and execute them, too.  In other words, we are finalizing
  reachable / rooted objects if they are inside the doomed AppDomain.  This is similar to what we do during a
  normal process shutdown. 
  Obviously the act of finalization can create more finalizable
  objects.  We keep going until they
  have all been eliminated.

• During finalization, we are careful to skip over any agile
  reachable instances like Thread instances that were created in this
  AppDomain.  They effectively
  escape from this AppDomain in a lazy fashion at this time.  When these instances are eventually
  collected, they will be finalized in the default AppDomain, which is as good
  as anywhere else.

• If we have any managed objects that were exposed to COM via
  CCWs, their lifetimes are partially controlled via COM reference counting
  rules.  If the managed objects are
  to agile instances, we remove them from their AppDomain’s wrapper cache and
  install them in the default AppDomain’s wrapper cache.  Like other agile objects, they have
  lazily survived the death of the AppDomain they were created
  in.

• For all the non-agile CCWs (the vast majority), the managed
  objects are about to disappear. 
  So we bash all the wrappers so that they continue to support AddRef and
  Release properly.  All other calls
  return the appropriate HRESULT for DomainUnloadedException.  The trick here, of course, is to
  retain enough metadata to balance the caller’s stack properly.  When the caller drives the refcount to
  0 on each wrapper, it will be cleaned up.

• Now we stop reporting all the handles, if they refer to the
  doomed AppDomain, and we trigger a full GC.  This should collect all the objects
  that live in this AppDomain.  If
  it fails to do so, we have a corrupted GC heap and the process will soon die a
  terrible death.

• Once this full GC has finished, we are free to unmap all
  the memory containing JITted code, MethodTables, MethodDescs, and all the
  other constructs.  We also unload
  all the DLLs that we loaded specifically for this AppDomain.

In a
perfect world, that last step returns all the memory associated with the
AppDomain.  During V1, we had a leak
detection test that tried to verify this. 
Once we reached a steady-state in the test cycle, after unloading the
first few AppDomains, we got pretty close to our ideal.  It’s harder to measure than you might
imagine, due to things like delayed coalescing of OS heap structures.  According to our measurements, we were
leaking 12 bytes per unloaded AppDomain – of which 4 bytes was almost by
design.  (It was the ID of the
unloaded AppDomain).  I have no idea
how well we are doing these days.

In a
scenario where lots of unloads are happening, it’s unfortunate that we do a full
GC for each one.  For those cases,
we would like to defer the full GC and the reclamation of resources until the
next time that the GC is actually scheduled.  …One day.

There’s
so much more I had intended to write about.  For example, some ambiguities exist when
unmanaged (process-wide) code calls into Managed C++ and has to select a target
AppDomain.  This can be controlled
by flags in the VTFixup entries that are used by the IJW thunks.  And customers often ask us for
alternatives to AppDomain unloading, like unloading individual methods,
unloading individual assemblies, or unloading unreferenced domain-neutral
assemblies.  There are many
interesting programming model issues, like the reason why we have a
CreateInstanceAndUnwrap method on
AppDomain.

But even
I think this blog is getting way too long.

In school, there were two kinds of tests. The regular kind where you learned and memorized all you could and then did your best on the test. The 2nd kind was the Open Book Test. Where you could use your notes and text books to figure out the answer to a question.

The 2nd was always preferable to the first because it was always a lot easier to prepare reference than to memorize.

Come finals time, a schedule of traditional tests meant packaging hours and hours to study. It was the ultimate experience of Information Overload. It also was the quickest way to forget everything you just learned the minute the tests were over. In fact, if you hung out with my friends and me, the minute tests were over, every penny we had was destined to be spent on beverages that killed more than a few braincells.

Today, life is so much simpler. I can’t remember the last time I had to go to the library or bookstore to search for a book on a topic that was important to me. I can’t remember the last time I HAD to invest the time to read a book as opposed to choosing to read a book that I wanted to read.

There was a time when I would scour online forums looking for any information that would give me an edge. Those days are long gone.

Today, I still read a ton of magazines that I both enjoy and which give me a solid foundation of information that help me professionally and personally, but I don’t stress that I might miss something. I don’t stress if I don’t read an issue immediately when it comes out, or if I’m out of town when its delivered. I used to.

Two things have

Also see: Silverlight and WPF Control Developer Huddle at Mix08

Also see: YouTube Tries to Get Legal

Also see: Interested in Artificial Intelligence? What about Wiki’s? Well, now you can have both.

Also see: Claimspace, a Long Tail Recognition System

Also see: Presentations…

Also see: Why Yahoo should say Yes to MicroSoft

Also see: Channel 9 Interview

Also see: Snippet Compiler update

Also see: VS.NET Macro To Group and Sort Your Using Statements

changed dramatically over the past 5 years. The first is that search engines have matured to the point where just about everything is indexed, from webpages to books to videos. Life has become an open book test. Between Google for News, video and web, Live.com for images, Icerocket.com for blog and RSS and Amazon for books, its pretty easy to find everything and anything from anywhere. It doesn’t matter if I’m in front of my PC, or sitting on an airplane or just with my phone at a game. Information is available.

The 2nd is the threading of information. Sites like Techmeme connect articles so that its easy to not only keep up with technology topics of interest, but to follow related conversations. Techmeme like sites are popping up for most vertical categories, so keeping up is far far easier than the old days of waiting for your PC Week , InfoWorld and Computer Reseller News !

Information overload is having to read everything and remember it. Open Book life means knowing where to look to catch up when you are ready to catch up.. I will take the Open Book Life anytime

Permalink  | Email this  | Linking Blogs  | Comments

http://www.blogmaverick.com/2008/03/10/we-live-in-an-open-book-world-the-lie-of-information-overload/

I have been trying to find a way to allow you to run Virtual PC 2007 with multiple monitors.  Natively VPC 2007 doesnt support more than 1 monitor, however you can “trick” it by using various techniques that expand the desktop area into a larger virtual desktop.

I tried using the awesome MaxiVista tool which can extend your screen across separate PC’s (think “push” remote desktop), but the new multi-monitor compatibility feature of VPC 2007 (which inexplicably does not add multi-monitor support) made this difficult since it ensures that your desktop recaptures your mouse when you move it outside of the VPC window thus preventing the extended screen from being accessible.

So, instead I tried the Remote Desktop approach mentioned in Steven Harman’s blog post.  

Here is a quick rundown on how it works:

Connect 2 monitors to your PC (more than 2 typically don’t work with this approach).   Make sure to extend your desktop onto the 2nd screen via Display Properties -> Settings.  Then launch Remote Desktop (mstsc.exe) with the “/span” flag:

mstsc /span

Then just use Remote Desktop as usual by specifying your VPC’s computer name in the connection dialog.

When I first tried this, it still didnt work exactly right.  It kept giving me annoying scrollbars instead of going full screen, so I added this extra flag to force it into fullscreen:

mstsc /span /f

Also, since I didnt want VPC to have the extra overhead of maintaining 2 sessions (the console and my new RDP session), I threw in one more flag to make it simply take-over the initial console window:

mstsc /span /f /console

NOTE: The /span flag is only present on the very latest version of Remote Desktop Connection.  Therefore, you must either be running Vista on both PC’s, or install the update specified here:

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

There are limitations on how your  monitors must be configured in order for this flag to work.

Also, keep in mind that this technique only enlarges your desktop area sufficiently large enouch to span both monitors, but it DOES NOT behave exactly like the native dual-monitor support you may be accustomed to.  For example, when you maximize a window, it maximizes across BOTH monitors instead of maximizing within the confines of a single monitor.   For now, I’m just dealing with that by avoiding maximizing and just manually resizing windows to fit 1 screen.

Advanced Users:

One way to avoid having to arrange windows each time is to use a cryptic, yet incredible tool called Hawkeye ShellInit. ShellInit is a small application that helps you manipulate your desktop & application windows via script.   Here is a small script that will move Visual Studio over the right-hand screen (assuming 1280×1024 resolution) and enlarge it to the correct size.

Position Window, *Microsoft Visual Studio, wndclass_desked_gsk, 1280, 0, 1288, 1002 

If you decide to use this tool, make sure and read the readme.txt file for some good sample scripts and ideas.

http://weblogs.asp.net/lhunt/archive/2007/10/11/vpc-2007-dual-monitor-support.aspx

Also see: UI design

Also see: A quick update on me.

Data Types a la Carte. Wouter Swierstra.

This paper describes a technique for assembling both data types and functions from isolated individual components. We also explore how the same technology can be used to combine free monads and, as a result, structure Haskell’s monolithic IO monad.

This new Functional Pearl has been mentioned twice in comments (1 , 2 ), and has now also appeared with comments on Phil Wadler’s blog. Obviously it’s time to put it on the front page.

http://lambda-the-ultimate.org/node/2700