Anders Hejlsberg: Questions and Answers

I haven't even listened to it yet ... but I wanna say.. Go Charles!! Great work!

rock on!

great bro

I noticed that there are a number of C9 videos that no longer support download resume. For us folks in Africa this is very bad. Any chance you guys can re-enable this?

Great stuff, thanks guys!

Thanks Charles, for bringing up the "Why call it unsafe?" :)

internal class AccessPointAO : AccessPoint {
public AccessPointAO() {
Id = Guid<GuidTypes.AccessPoint>.Default;
Disabled = Boolean<NormalBool>.False;
Caption = String<Length255>.Empty;
Notes = String<Length2000>.Empty;
}

public Guid<GuidTypes.AccessPoint> Id { get; set; }
public String<Length255> Caption { get; set; }
public Boolean<NormalBool> Disabled { get; set; }
public String<Length2000> Notes { get; set; }
}

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!

 

Thanks for the awesome video!

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

Cool, thanks Charles.

Absolutely tired today, thought I'd watch a bit, but it was so good I watched to the end.

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

Thanks Charles.

Charles: With regards to the download with resume issue, please see this link:

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

Thank you Charles for asking my question and I have to say a fantastic and informative reply from Anders. Explaining that a "simple proposal" is/isn't possible because of axioms created when the language was first designed. It has change the way I think about C#.

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. 

Thanks Anders, and Charles for the great interview.  Lots of interesting facts and information.  I wanted to wait to post until I've formulated some intelligent followup commentary and questions, but that could be a while, so I just say thanks for now.

I wish you'd publish transcripts rather than requiring us to watch video. It'd be easier for me because I have sound disabled on my machine and can't enable it unless I get hold of some earphones (so as not to disrupt others' work), and also because a transcript is easy to read quickly and thus less time-consuming. But I wonder what deaf and hard-of-hearing developers do - there does seem to be a lack of consideration.

I agree with some posters above. The media file download should be resumeable just like C9 in the old days. I notice this change recently and it seems the files are now hosted in Windows Azure. It's not very convenient to download a non-resumeable file, especially using dial-up connection.

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.
----------------

Nice interview! Looks like C# is turning out to be a great language.

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)?

Nemerle and Boo has already Metaprogramming support on .NET world. I don't understand why he ignores them and reference ruby .

@m4h4r4 @DompfKopp: Re: download issues, I've moved the discussion to Site Feedback 

great interview listening to anders is allways interesting

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

@aL_: I think Anders stated that he was not "a fan" of Rx per se as it forces developers to think differently, so I cannot see any language support for some time until a way is found for making Rx easier to deal with

Just finished watching, another great video. 

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

@PerfectPhase:  Maybe The C# Programming Language 4.0

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)

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"));

 

Thanks for asking and answering my questions, Charles and Anders. I really look forward to being able to use async professionally at my company, it's marvellous to behold the simplicity of async and how it plays well with other features of the language. I wonder if CaaS has a role to play in frameworks such as WF but also would love to have something like a REPL-enabled LINQPad or Microsoft equivalent.

I think Anders will be very interested in the paper Representing Monads http://www.diku.dk/hjemmesider/ansatte/andrzej/papers/RM-abstract.html

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.

@Jules.dot: Cached PDF is available here:  http://citeseer.ist.psu.edu/viewdoc/download;jsessionid=855D0B2B0B7E2A6459D9EC5B52381BB4?doi=10.1.1.43.8213&rep=rep1&type=pdf

For anyone interested in what higher kinded types in C# would be like and useful for, there is a very good blog post by Joe Duffy on the subject:  Longing for higher-kinded C#.

Nice interview!  VB.Net needs love too!

Interesting interview, indeed.

I'm looking forward to that CaaS stuff that will, if I understood Mr. Hejlsberg correctly, bring vastly improved meta-programming support to C#. I also agree, that meta-programming shouldn't feel to different from "normal" programming in the sense that one should be able to use C# itself to
write code that generates C# code, instead of using some rather weired, purely-functional template language (and I'm a guy that loves Haskell!) that happens to be accidentaly Turing-complete...   While C++' template system may be incredibly powerful, it certainly isn't really nice to use for general-purpose meta-programming tasks (probably that's simply because its original purpose in fact wasn't meta-programming, but providing support for parametric polymorphism).

Still, I'm a bit worried about how that meta-programming support will actually turn out to be. If it's "just" about runtime code generation, you'll probably always have to call the generated code through a delegate, so you couldn't really use it for optimization purposes (e.g. generating specialized code for some kinds of LA calculations); because of the extra level of indirection, delegate calls are often just to expensive for that purpose as they cannot be inlined by the current JITer, as far as I can tell. After all, there's a reason why F# introduced FSharpFunc (or FastFunc, as it was called back in the days) instead of using delegates for representing closures.

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

Interesting stuff, as always; thanks to the great Anders.

Great interview. It's been too long since Anders has been on C9.

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.

First of all, thank you Charles for interviewing Anders! (I know you prefer talking about native code, hehe)

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.

Interesting talk...thanks to Mr. Hejlsberg!

if you remove null, you would need undefined! null is much times better than string.Empty, and it even is sometimes to difference between true, false and not set_! all types should be nullable! undefined is only an interpreter hit in js, but whats cool there is, that variables may be like string.Empty, 0 or null, but they are equal.
What i don't like in c# is: static members are not overridable, that interfaces don't define constructors and that there's no way to enforce overriding base class members, that are not declared to be overridable. interfaces should have much more priority, especially methods that i have to implement today as extension methods!
But you say yourself, we don't do features more likely than doing features that don't work. Much respect for your work, Anders!

@Uli:  He wasn't suggesting removing null, just making it possible to define reference types that are not allowed to be null.  Just like a value type like Int32 cannot be null, there would be some default value, and/or you have to initialize it, and when it's passed around it can't ever be null, therefore you don't have to check for nulls when the reference is passed around.

@Uli:  Also, it doesn't make sense to have static members that are overridable (they aren't even members, because they belong to the class, not an object - which is an instance of a class).  Virtual methods are required to be defined in classes which can be instantiated, with the overrides in sub-classes.  Thus when you invoke a virtual method, the overriding method is looked up in a vtable for dynamic dispatch, which is the opposite of static.  See http://stackoverflow.com/questions/1243836/c-virtual-static-method for more!

@Uli: Why would an interface define constructors?  Constructors are not dynamically dispatched.  You either construct a object of a certain type, and if it is based on another class, you call the base constructor if required.  How would virtual constructors work?  You have to say what you want to new up.

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.

Awesome ! Now watch it again !

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.

I was not clear on my dependancy property question. I would find it useful if I could define a method be called whenever a property in an object is changed. Expanding that feature to its logical conclusion, signal an "event handler" whenever a method of an object is called.

@SteveRichter: Not sure if this is what you are saying, but I would treasure syntactic sugar around INotifyPropertyChanged, allowing POCO default getters and setters like "get;" and "set;" to be used for dependendency properties.

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")

 

I have a feeling that he is talking about Attached Properties instead of DPs. Could this be?

Anders, having heard you talk about closures and privacy in JavaScript, have you read this article: http://www.codeproject.com/KB/ajax/SafeFactoryPattern.aspx ?

Great interview!

Great interview! Thanks Charles, Andres!

..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...

@koistya:  See http://channel9.msdn.com/Forums/Coffeehouse/Project-Midori-is-building-with-a-new-programming-language for some information and speculation.

@koistya: Let's call it C##.

Charles: The video skips constantly, to the point where it's simply not watchable. Whole sentences get cut, the video feed gets out of synch with the sound and freezes, etc. It's the second interview on Ch9 where I see these symptoms -- I am guessing it's a bandwidth problem. I am on corpnet though, so I am surprised that even us Microsofties are seeing these symptoms.

Hey Charles, this was great, my only regret is that I missed the call for questions.

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.

I would also like to hear Anders opinion regarding CodeContracts....

 

• 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).

@Richard.Hein
Consider System.Attribute and it's IsDefined method. You could call XmlTypeAttribute.IsDefined(...) but that's running always the same Attribute.IsDefined method. So statics should not be overridable but like overloadable: They should be explicit to the defining class type. So there's only one Attribute.IsDefined. A derived XmlTypeAttribute doesn't have that static method, until the author of XmlTypeAttribute wrote it.

My idea to interfaces is that they should more be like a shape to a class. Like abstracts they may itself implement a prototype function that's called, if a class doesn't implement it itself.
In the case of constructors the interface may only be descriptive or constraining for a class - there's no virtual interface method, but an explicit implementation in the class.

> to prevent people from overriding them
there are 2% people out there, they don't say C-what (piece of T)? A dev should know what doing, or try again - it's not dead or alive!

> "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.
The idea of abstract like development around a type, but outside of a specific member. There are many times pieces of code also inside the base classes, that are twice coded but doing the same thing. Extensions do really very good but it's sad that IsNullOrEmpty, IsNullEmptyOrWhiteSpace and so on aren't extending string. Think about IsDefined<AT>(this AT attrib, MemberInfo, bool ;)

ey: Anders is cool, that's what i would say here :P

It is funny that Anders used Linq as an example of a language feature he does not deem possible as a third-party extension, because Nemerle does it very successfully. Is Anders really so uninformed as to say "I don't think that anyone knows how to do that" or does he ignore Nemerle on purpose?

I always pay Anders the most respect!
I always pay close attention to him by the Microsoft OC.
I has resigned yestoday, that means I can't pay close attention to him any more.
Now, he has been offline for 6 hours. I'm strongly want to say 'bye' to him by the OC, but I just don't want to disturb him.

Then, BYE! (→_→) (>_<)

That's great!

gggggf