posted by Keith_Flo

posted by koo9koo9

You can download the files directly by clicking on the Download links next to the player. I'm not sure what you mean by enabling download/resume? It could be that you are talking about progressive streaming versus smooth streaming (which is the default)? Can you be more specific in terms of what you want us to do?
C

posted by Charles

posted by Bas

posted by Stewart

1 hour ago, Charles wrote

Hi DomfKopp,

You can download the files directly by clicking on the Download links next to the player. I'm not sure what you mean by enabling download/resume? It could be that you are talking about progressive streaming versus smooth streaming (which is the default)? Can you be more specific in terms of what you want us to do?
C

I think I know what he means, I was downloading a bunch of HQ-WMV videos the other day from C9 to watch offline and I had to stop the download midway through,  When I went to restart the downloads they all failed, had to be restart from the beginning rather than resuming from ~80%

Anyway really looking forward to watching this video, top work Charles and the team!

posted by PerfectPhase

Got to know more about C# in a fresh manner. :] 

posted by AgnisM

posted by Ian2

Anders is so good at explaining complex issues, he is inspirational.

Thanks Charles.

posted by vesuvius

http://channel9.msdn.com/Forums/Feedback/mediach9ms-VS-filesch9ms

posted by N2Cheval

It's a shame it this wasn't an interactive interview (with question from the "audience"), as I would have loved to ask a follow up question based on the content.

From the interview I get the sense that Anders would like Meta-Programming in C#, where the language used for the meta-program is also C#. So I would have liked to have asked him, what are his (Anders) thouhts of other .net languages where this is already possible? like Nemerle and Boo. 

posted by AdamSpeight2008

C

posted by Charles

posted by Richard.Hein

Here's the log I got using FDM (Free Download Manager):

----------------

GET /ch9/b0be/c77d5232-4d38-474d-80a5-9ed20166b0be/AnHourWithAndersHejlsberg_2MB_ch9.wmv HTTP/1.1
...
Host: media.ch9.ms
16:57:30 04/05/2011 HTTP/1.1 200 OK
Content-Length: 629089625
...
Server: Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0
...
Date: Wed, 04 May 2011 09:57:35 GMT
...
Server does not support download resuming. Don't stop this download; otherwise you'll have to start it from the beginning.
----------------

posted by mahara

For now though, I am enjoying the succinctness of F# without losing anything. I have to admit learing F# was harder than I thought as I did not have a funcitonal programming background.

My question is more appropriate for the CLR team but I will ask anyway. It seems that OO-based platform (such as CLR and JVM) are not super optimized for symbolic computing (I learned while reading "F# for Scientists" by John Harrop). Are there any plans for supporting symbolic computing more efficiently? To be honest I don't even know what that even means in terms of CLR changes. I suspect it has to do with creation and garbage collection of extra objects that perhaps can be avoided if the CLR is further optimized for functional languages.

Considering that both CLR and JVM have added special support for dynamic languages (so that dynamic method dispatch is optimized) can something similar be done for F# and other functional languages (Scala and Clojure)?

posted by fwaris

posted by PerfectPhase

what i ment in my question about events was more if there where thoughts on making events 'awaitable' and/or more easily converted into IObservables.

You can still do that right now through apis like FromEvent(i think its called) in Rx but its kinda clunky and either invloves magic strings or delegates that can be tough for people to get their head around.

making it legal to 'await' an event or cast it to an IObservable (or something) would really help reducing boilerplate code

posted by aL_

posted by vesuvius

Anyone know what the green and white book on Anders desk was?

posted by PerfectPhase

I did not know it was out so I will get a copy. What I love about the .NET development series is they are very affordable. One more copy on it's was to my house (or hoose as they say up here)

posted by vesuvius

4 hours ago, aL_ wrote

You can still do that right now through apis like FromEvent(i think its called) in Rx but its kinda clunky and either invloves magic strings or delegates that can be tough for people to get their head around.

The newest version of Rx:

var clicked = Observable.FromEventPattern<RoutedEventHandler, RoutedEventArgs>(eh => this.button1.Click += eh, eh => this.button1.Click -= eh);
clicked.Subscribe(e => MessageBox.Show("Clicked"));

posted by Richard.Hein

posted by exoteric

It answers exactly the question how to generalize and unify Async and Iterators. Interestingly and perhaps surprisingly (or perhaps not if you know F# async) it also unifies these with LINQ (monads)!

The reify operation in the paper corresponds to the async keyword, and the reflect operation corresponds to the await keyword. There is a difference between the paper and C#'s async support, because the former use a global CPS transform whereas C#'s is a local CPS transform. Still, you can do the same generalization of async to reify and await to reflect with a local CPS transform.

Their technique being global CPS transform (which was already done by the SML compiler, or perhaps it used another technique to support call/cc), they can "yield" across functions, even if they are not marked as iterators or async. The other difference is that reify ("async") is not applied to a method, but to an arbitrary subexpression.

posted by Jules.dot

posted by Richard.Hein

posted by Richard.Hein

posted by mxj1009

Anyhow, C#' future will bring exciting stuff, that's for sure.

posted by Novox

posted by Regev Porat

Someone recently asked me to describe Scala... I said it was like a c# version of Java 

It was somewhat tongue-in-cheek, but the thing is that for the most part c# code looks very clean, as does Scala code, and the addition of Lambda's and closures to the language has made a huge difference to the way people write production code. Look at most of the modern libraries being written, like TPL etc and see the high usage of Lambdas. All those design patterns with single method interfaces that took loads of boiler-plate code (so they were rarely used) now boil down to simple functional patterns. In some ways some of the Async examples that get shown look old fashioned compared with that in that it is often shown in combination with things like for loops... which really look like a cumbersome way to iterate these days: hardly the poster child for imperative programming, non-local returns etc not withstanding.

Still Async in combination with Tasks are a very powerful and useful concept. Very similar indeed to JavaScript framework support for deferred and promises, and useful for many of the same things.

posted by Parmenio

As CaaS will have a tremendous impact in many peoples productivity (I bet it will be _the_ killer feature), any updates about roslyn are highly appreciated!

As a sidenote: When Anders talked about the time he worked on visual programming and small demos that work, but real world stuff that drowns in its own complexity, it reminded me of a project I worked on when the workflow foundation just came out and in a fit of the latest and greatest it got used for all the wrong reasons. Argh - just remembering the agonizing slow designer when it tried to popluate the screen with an 'if' and a 'while' loop makes my head hurt. Never again - to steal Anders words: I've come to peace with code.

posted by mdk

posted by Charles

posted by Parikshit

posted by Uli

posted by Richard.Hein

posted by Richard.Hein

There is very good reasons for why all methods are not virtual.  The whole point of making things non-virtual is for a) performance, and b) to prevent people from overriding them because there's a good reason to prevent them from doing so.  Consider if a method is used from within a base class, to do something like set a private member variable, and then you override that method and can/don't know about the private member and cannot/do not set its value.

You can force people to override methods by making them abstract; however only abstract classes can have abstract methods.  If you want to force someone to provide the implementation for some method in another fashion, you can make the method take a delegate to be invoked, so if the method is used, the caller has to provide the body:

class Foo
{
    public T NeedABody<T>(Func<T> f)
    {
        return f();
    }
}

// ...

var foo = new Foo();
var result = foo.NeedABody(() => 6 * 7);

Also, I could do this (or use an Interface instead if I don't need to inherit from Foo):

abstract class Bar : Foo {
    public abstract T MustOverride<T>();
}

class FooBar : Bar
{
    public override T MustOverride<T>()
    {
        return default(T);
    }
}

"interfaces should have much more priority, especially methods that i have to implement today as extension methods!"  I don't know what you mean here.

posted by Richard.Hein

posted by felix9

19 hours ago

if you remove null, you would need undefined! [...] all types should be nullable!

It's not about removing, it's about being able to specify null-safe reference types.

19 hours ago

all types should be nullable!

Heaven forbid! Consider that: C.A.R. Hoare calls the invention of the null reference his "billion dollar mistake" (http://qconlondon.com/london-2009/presentation/Null+References:+The+Billion+Dollar+Mistake).

Why do you think, we need null references? If you want to model operations that can fail and return non-null types, use an option type (like Haskell's Maybe monad or F#'s option) to wrap the result.

posted by Novox

posted by SteveRichter

3 days ago, Richard.Hein wrote

*snip*

The newest version of Rx:

1 2	var clicked = Observable.FromEventPattern<RoutedEventHandler, RoutedEventArgs>(eh => this.button1.Click += eh, eh => this.button1.Click -= eh); clicked.Subscribe(e => MessageBox.Show("Clicked"));

 

thats the one  i mean, its fine for you and me, but that going to be alot more difficult for normal people to understand than

button1.Clicked.ToObservable().Subscribe(e => MessageBox.Show("Clicked"))

or

await button1.Clicked
MessageBox.Show("Clicked")

posted by aL_

Great interview!

posted by dcleao

..Just out of curiosity, isn't it possible to start a new "branch" of C# language and .NET Framework, redesigning it from scratch? Thus keeping existing customer base on previous brunch and without breaking any existing code bases; and new customers will be able to to use this new "branch" if they want to.

For example in a world of cloud computing, the base class library as we know it in .NET 4.0 doesn't bring simplicity to the table (because it wan't designed for a cloud app platform at the first place). IMO, the base class library on Windows Azure or similar cloud platforms should differ dramatically from existing .NET 4.0 as we know it today...

posted by koistya

posted by Richard.Hein

posted by rgruian

posted by rgruian

Change the Video Streaming setting in your C9 profile from Smooth Streaming to Progressive and see if it sucks less. Corp IT is aware of this issue and it won't always be like this Secondly, for the rest of the world, the real world, we know that this issue exists even outside of proxy-controlled networks and we have a solution....

C

posted by Charles

Regarding Anders opinion about going back and allowing non null reference types (something I've actually found myself missing from C++) isn't that somewhat obsoleted by the advent of CodeContracts?

I'd love to hear Anders opinion on something like CodeContracts which is language agnostic and through static analysis (abstract interpretation) actually manages to prove parts, if not whole parts, of your program correctness.

I know you'll get back to Anders eventually, if you haven't already asked him about it, but from his unique position as a language designer something like this ought to have some appeal.

posted by leidegre

posted by koistya

• Is this "not support for non-nullable-reference-type" a c# or clr feature?

• Currently in enterprise software the case is often that we would need some common functionality
  without knowing the exact type. When we don't have higher order types this usually
  leads to reflection (and runtime-errors).

posted by Thorium

posted by Uli

posted by Don Reba

posted by Lincal