Comments

Holy smokes... yes this is understandible; yes your past installments were understandible; but oh my absolute god and all which is holy, your method of trying to teach the content in this video was horrible..... Yes its can be followed and understood following your spaghetti-logic? explination, ultimately conveying the proper message.  Then again I can also follow x86 assembly fairly well too, and I would compare your explination as a jumble of C & x86.
I honestly can't believe how mentally exausting your method of explination, metaphores, and actual examples were here.  It was far more complex than you had to make this stuff unless you explicitly wanted to try and give theory, connections, reproductive methods and a practical example all mixed into one schmorgesboard, thereby achieving your goal I suppose.

I just had to mention this because seeing your previous videos, and seeing how clear you could have made this, you are far better than this for teaching people.  
Maybe you shoud try to bite-size the reproduction methods and therory into a prelude to the examples you intend to give.  
I just feel bad for the person above (and future others) admitting defeat to these as well as giving up on even attempting to understand the rationale, don't you?

 

Have you considered "bottom" to express null equivalency in your syntax for your core implementation? As a singular binding bottom function application equal to null might do the trick.

http://en.wikipedia.org/wiki/Bottom_type

Im no LINQ or C# pro, do you think it would be a suitable solution for you Bart?

@CoreySanders: Azure is indeed all you say, but the way in which it's marketed and advertised seems to be the root of the many misconceptions and assumptions people have about it. I'm sure that as part of the Fabric Controller team, you have been asked questions which are great dreams and goals for people to reach via the technology they create, but I can imagine how grinded you feel for explaining an equivalent situation in which makes their vision feasable.  As engineers, the "sky" is the limit and only limited by our imagination and budget, but the expectations of Azure are usually a little excessive for many people, and overestimate its ability until learning of Azure's domain(strengths & weaknesses).

@aL_: I think Azure COULD probably be retro-fitted to a general hardware configuration if and only if they restore the origional kernel of Server 2008 R2 + Azure extensions instead of using their extremely stripped down kernel which they have engineered specifically for the hardware in their datacenters for apparent optimisation. If the kernel wasnt so specialized, and they didnt design pieces of the intergral components as being so specialised to their specific server configs with assumptions in hardware ability offering the same functionality, they shouldn't be limited by their datacenter configs. But maybe by vendor lock-in decision, they will never actually offer a more maleable Azure for corperate installation, which is sad but not impossible.

Actually STL, to me the usage of lvalues and rvalues being referred to as left & right makes sense when thought of to be similar to key-value pairs. With the left lvalue being the "key" and the rvalue being the "value" which lives at the lvalue. In this way of thinking about them, I will try to explain using a table, where lvalues are user defined and named, and the rvalues are the compiler managed values which are refrenced internally as temporaries with lifetimes managed by the compiler.

User defined named; lvalues which is our explicitly given name for a location:

-------------------
| lvalue | rvalue |
-------------------
| cat1   | fred   |
| cat2   | jerry  |
| cat3   | steve  |
-------------------

Compiler defined temporaries; rvalues given temporary named locations with their lifetimes managed by the compiler:

-------------------
| lvalue | rvalue |
-------------------
| temp1  |   11   |
| temp2  |   22   |
| temp3  |   33   |
-------------------

As you can see, we can refer to our managed/uer-defined variables using our named location(lvalue) while on the other hand, the compiler generated temporaries arent usually cared about, where we only want their values that they contain(its rvalue). Even though lvalue could also mean location value and rvalue meaning return value, whichever way you like best, it IS possible to think of them being left & right in my opinion.

I must say, STL this video was the video I enjoyed the most of your 9 videos, even though it wasn't specifically aimed at an STL feature, because you finally delved into a more technical subject making this valuable.

Do you also think this makes sense??

In my opinion, glorifying Azure to be a whole "Operating System for the Could" is almost a stretch. Azure to me is equivalent to a LAMP server stack backed with a partially specialised load-balancer + memcached. 
And primarily the fabric controller is nothing but a _slightly_ more advanced memcached service in contrast to a "kernel". To me a more true statement would to call Reddog OS the "kernel" of Azure.

It seems to me as if Azure is being regarded more of an actual OS instead of the server stack and services for its distributed and scalable nature. 
Mark, I expect that once you decipher the memcahed functionality of the fabric controller, you'll miss the real fun kernel stuff in due time.
On a different note, I was saddened that I was busy for most of PDC's live viewability to force me to miss out on the more in-depth questions I would have asked live instead of far past it's date.

The only real thing I could ever see myself paying for Azure as an end-user, would be if Microsoft had some sort of way to PXE/network boot a VM of Windows 7 running up on the "cloud" in which I could do all my computing needs via remote-desktop through an XBox360 client-to-AzureVM connection or a specialized Microsoft thin-client hardware monitor & input device package instead of a whole physical rig at my feet.

I always enjoy hearing Mark speak, and I hope this all/some of this comment made sense to all/some of you

Bye for now!

I have a few bookmarklets I have pasted into a few pastebins that you can all look at as examples of how I use them, which is great cross-browser functionality which I keep synchronised among Opera 11, Chrome Dev, IE9 Beta and Firefox 4.0b8 nightlies.

https://gist.github.com/712735

http://pastebin.com/4bpX6ueZ

http://pastesite.com/20290

http://codepad.org/m4RYIG25

http://ideone.com/VSjoN

Enjoy, as you ca just paste in a line starting with "javascript:" into your URL bar and try one out to see what It does.

PS Your spam filter sucks thinking my links are spam...

 

 

Well when I think of Acync, I think of asynchronously pushing tasks waiting to be done on to a core which is the one next in line, which would also be specific per machine. I'm no C# coder but heres a Pseudo-C# way I think I could describe what I'm thinking.

class DispatchThreadsAsync
{
  static void Main()
    {
      const int maxThreadCount = Enviroment.ProcessorCount;
      var workToBeDone  = new List<Task>();
      int threadNumber = 1;
      while (thread < CONCURRENCY && thread != 0)
      {
        foreach (int workItem in workToBeDone)
        {
          async workToBeDone.Add(ScheduleNextThreadAsync( threadNumber , workItem ));
        }
        threadNumber = thread.nextAvailableThread();
      }
   }
}

So I mean that to capture a dynamically scheduled loop method thingy that schedules un-even workloads as threads onto cores which become available. Asynchronously creating/reusing/receiving thread tasks per work item in a work queue as long as work is available.

To me that would be a cool way to dynamically dispatch newly created work items and threads.  And I'd suggest that the C# team see if this type of method for creating tasks of work to be done could be made into a nice little industrial-strength official C# 5.0 asynchronous task method

As I said im no C# coder but I tried my best to pseudo-C# my point across by what I think would be a good abstraction unless it already exists of course and I haven't looked hard enough

For general purpose, I believe the complexity of shearsort is something like O(n^{^1/2 (}log n)) or equivalent to: Im glad my tablet functionality comes in handy every once in a while

But I AM quite pleased to have heard you mention that your STL implements an IntroSort its pretty awesome since SGI's STL implementation has IntroSort as the default too.

This URL is awesome since you can customize, this is how I compare sorts haha, when their bad implementation doesn't bug out of course

http://home.westman.wave.ca/~rhenry/sort/duel.php?width=600&height=1000&alg1=ShearSort&alg2=IntroSort

I made it be around screen width(each 600 wide), both sorts using 1000 entries to sort, Comparing side-by-side my new fav Shearsort with the also impressive IntroSort. The bigger N, the better Shearsort can do, since its complexity stays way down,  and is excellently-parallel n-way per "shear".

At least the need for manual loops has almost been completely eliminated .

int main (int argc, char *argv[])
{    
    unsigned int fact = 0;
    cout << endl << "What factorial do you want to calculate?  ";
    cin >> fact;    
    vector <unsigned int> vec(fact);
    iota (vec.begin(), vec.end(), 1);
    cout << endl;
    cout << "Factorial is: " << accumulate (vec.begin(), vec.end(), 1, multiplies<unsigned int>() );
    cout << endl;
    return 0;
}

I've been spraining my brain recently with how to implement Shear-sort, its absolutely cool,entertaining and fast.  Shell & Radix soort used to be my favs, but now its shearsort.  Have a look at it, you also may find it fairly entertaining.

The ability to make a workable Y-Combinator(Fix point recursion of annonymous functions) aren't really possible to do (DIrectly) with the MS version of the STL at this moment, but you can make your own class to make the combiner since this seems to be whats limiting:

// IMPLEMENT _STD tr1::bind
    // PLACEHOLDERS
template<int _Nx>
    class _Ph
    {    // placeholder
    };

Seeing that in the VS2010 headers make me sad inside  BUT an implementation should be find if you use the bost::bind or tbb::combine_each to allow strict binding for a solution with 1 combiner function for the usage in the C++0x lambda calculation.