Live Chat Programs

Sometimes you got to brag. Tuesday nights on HDNet is News Night. We lead off with Dan Rather Reports
Dan has brought back real news with a full 60 minutes of reporting on news that matters. If you haven’t yet, check out some of his reports that we are streaming online

DRR leads right into HDNet World Report. World Report, which is produced by Dennis OBrien doesn’t get the visibility that Dan Rather Reports gets, but it knocks out great stories from around the globe week after week. Today, HDNet World Report finally started to get some of the recognition it deserved. Today, at the 74th annual National Headliner Awards, sponsored by The Press Club of Atlantic City, N.J. HDNet walked away with first place winners in TWO categories !

The first was for Documentary or Series of Reports: HDNET, “The Forgotten Front: Terrorism in the Phillipines; beating out CNN with their amazing “CNN Presents: God’s Warriors;” and CNN for their , “Children of the Storm.”
Our 2nd win came for News Magazine Program: HDNet World Report, “Uganda’s Silent War ( a co production with Newshour with Jim Lehrer);” finishing ahead of 2nd and 3rd place finishers, Dateline NBC, “To Catch a Con Man;” JumpStart Productions/NOW on PBS, “Casualties of War”.

You don’t have to be the biggest to beat the best, but you do have to outwork the bigger players. Congrats to everyone at HDNet and the entire World Report team for doing amazing work and making us proud.

This is just th (more…)

Jeff Atwood recently posted about natural sorting. This is all about making sure that strings that contain numbers sort numerically. I’m slightly surprised to see that he wants to call it alphabetical sorting. Surely by definition, alphabetical sorting is defined by, well, the alphabet. This is an issue about numbers, not letters.

Anyway, he says he tried and gave up on a succinct C# version. He suggests that it will take 40+ lines of code. I believe that’s misleading, because as far as I can tell, the Python versions are only able to be so succinct because Python already appears to know how to sort an array. Both examples he shows rely on this. In.NET, collections aren’t intrinsically sortable. Let’s sort that:

Also see: From C# to Java: Part 4

/// <summary>
/// Compares two sequences.
/// </summary>
/// <typeparam name=”T”>Type of item in the sequences.</typeparam>
/// <remarks>
/// Compares elements from the two input sequences in turn. If we
/// run out of list before finding unequal elements, then the shorter
/// list is deemed to be the lesser list.
/// </remarks>
public class EnumerableComparer<T> : IComparer<IEnumerable<T>>
{
 /// <summary>
 /// Create a sequence comparer using the default comparer for T.
 /// </summary>
 public EnumerableComparer()
 {
 comp = Comparer<T>.Default;
 }
	
 /// <summary>
 /// Create a sequence comparer, using the specified item comparer
 /// for T.
 /// </summary>
 /// <param name=”comparer”>Comparer for comparing each pair of
 /// items from the sequences.</param>
 public EnumerableComparer(IComparer<T> comparer)
 {
 comp = comparer;
 }
	
 /// <summary>
 /// Object used for comparing each element.
 /// </summary>
 private IComparer<T> comp;
	
 /// <summary>
 /// Compare two sequences of T.
 /// </summary>
 /// <param name=”x”>First sequence.</param>
 /// <param name=”y”>Second sequence.</param>
 public int Compare(IEnumerable<T> x, IEnumerable<T> y)
 {
 using (IEnumerator<T> leftIt = x.GetEnumerator())
 using (IEnumerator<T> rightIt = y.GetEnumerator())
 {
 while (true)
 {
 bool left = leftIt.MoveNext();
 bool right = rightIt.MoveNext();
	
 if (!(left || right)) return 0;
	
 if (!left) return -1;
 if (!right) return 1;
	
 int itemResult = comp.Compare(leftIt.Current, rightIt.Current);
 if (itemResult != 0) return itemResult;
 }
 }
 }
}
	

(more…)

It’s been over two years since I blogged.  Although I remain happily (perhaps even ecstatically) working at Microsoft, I left the CLR team and the Developer Division about a year ago.  I’m now on an incubation team, exploring evolution and revolution in operating systems.  This is a fascinating area that includes devices, concurrency, scheduling, security, distribution, application model, programming model and even some aspects of user interaction (where I am totally out of my depth).  And, as you might expect with my background, our effort also includes managed programming.< ?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

 

Anyway, this blog will remain available indefinitely.  It continues to be useful for certain technical details which are unavailable elsewhere.

 

In the meantime, if any readers are interested in working on a deep systems incubation with me and a team of truly outstanding developers, please send me email (cbrumme).  We are holding to some very high standards for this effort in terms of insight, experience and hard work.  But if you are like me, I am confident you will find it a dream opportunity.

(more…)

Eriskay: a Programming Language Based on Game Semantics. John Longley and Nicholas Wolverson. GaLoP 2008.

We report on an ongoing project to design a strongly typed, class-based object-oriented language based around ideas from game semantics. Part of our goal is to create a powerful modern programming language whose clean semantic basis renders it amenable to work in program verification; however, we argue that our semantically inspired approach also yields benefits of more immediate relevance to programmers, such as expressive new language constructs and novel type systems for enforcing security properties of the language. We describe a simple-minded game model with a rich mathematical structure, and explain how this model may be used to guide the design of our language. We then focus on three specific areas where our approach appears to offer something new: linear types and continuations; observational equivalence for class types; and static control of the use of higher-order store.

In a substantial appendix, we present the formal definition of a fragment of our language which embodies many of the innovative features of the full language.

It’s always interesting to see a new programming language strongly based on some mathematical formalism, because a language gives you a concrete example to match the abstract semantic definitions to, and game semantics is something that I’ve been curious about for a while.

One particularly interesting feature is that the core language has a restricted model of the heap, which controls the use of higher-order store in such a way that cycles are prohibited. This is enforced with a notion called “argument safety”, which essentially prohibits storing values of higher type into fields which come from “outside” the object. This is somewhat reminiscent of the ownership disciplines found in OO verification systems like Boogie, which enforce a tree structure on the ownership hierarchy. It would be very interesting to find out whether this resemblance is a coincidence or not.

(more…)

Wow, it feels like old times…  I am happy that we are posting a new proposal for additions to the framework design guidelines.  Mitch has worked hard on these, and we have reviewed them internally and now it is time for your comments.   Please do chime in!

LINQ Framework Design Guidelines

 

Thanks!

http://blogs.msdn.com/brada/archive/2008/03/13/framework-design-guidelines-linq.aspx

In response to my penultipate post, reader “David” (the other David?) xClaims: “Um, I don’t get it - what’s this for again? Is it a microformat or something? I hereby claim xClaims are confusing.” My vote: Abstain + a Comment (below):

I hear you, David. And point taken. Note to Self: continue to refine messaging around Claimspace. Thanks for the feedback and keep it coming. As with any unreleased product and all true innovations (again, early June), it’s hard to predict how folks will use Claimspace. Usage will drive the messaging. But for whatever it’s worth, I *love* your first xClaim! And I point out that you just created the SECOND public xClaim, in history.

Also see: Java VM for .NET?

To your questions,

Question: “what’s this [an xClaim] for again?”
Answer: An xClaim is an author-defined, reader interactive rating/polling mechanism for the Web that enables a person to assert that, ‘I created this resource and I wish to be recognized personally or promote the recognition of my resource on these terms [my claim]. What do you think? Vote/Comment here.’

Question: “Is it a microformat or something?”
Answer: An xClaim is a control, not a microformat…yet. For my thoughts on the difference between a control and a microformat, see http://blogs.msdn.com/korbyp/archive/2007/04/12/microformats-are-like-rfid-tags-for-the-web.aspx. For any demonstration sites that we provide (more…)

Fritz Onion and I just finished the pre-conference ‘Day of Silverlight’ talk at DevWeek. Demos can be downloaded from http://www.pluralsight.com/fritz/demos/DevWeek2008DayOfSilverlightDemos.zip

http://www.interact-sw.co.uk/iangblog/2008/03/10/devweek-sl-demos