Where is C# in the Programming Language Lifecycle?

one thing to consider is the original design of the languages, we know that languages learn from their ancestors mistakes (and C# certainly has a huge advantage here), in the case of C# I don't know how much of the features in 1, 2, 3, 4 and 5 (I've seen Anders talk about it, the whole compiler as a service thing) were conceived initially, it seems to me it has evolved so quickly because those features were planned from the very beginning and split into the different versions; I think C# is still between the general adoption and acceptance phases and that it will take a *long time for people to catch up to the full power of C#

in my opinion new features of 4(like Optional)
is the road to Hell.

lock and volatile for new programmers is like magic scrolls. :)

New features should be added but about the particular optional parameter feature I agreed with Sergey.{It makes the polymorphism understanding very odd}

It's in its teens, having an identity crisis not knowing whether to stay static or become dynamic.

I will second (or third) on the Optional parameter feature. It's one of those things that makes VB suck, and now it's here to make C# suck. Annoying, really.

The dynamic direction is interesting, but I'd rather use F# or the Iron languages to enjoy the advantages of true dynamic programming.

That's why I use VB, a timeless classic.

(Just kidding, don't jump on me)

I'm not sure if the 7-phase lifecycle completely applies to c#, because unlike most other languages (c,c++, java, perl, etc), we can really speak to the lifecycle of the runtime and the lifecycle of the language separately. While c# might be reaching the maturation phase, the underlying runtime is in a much longer cycle, and is probably sitting somewhere between adoption and acceptance. This allows upshots like F# to come along at the conception stage of their own lifecycle, giving both the runtime and its sibling languages a shot in the arm.

The assumption here is that you're working with a language that can't change itself. But not ever language fits that assumption, although C# certainly does.

I will second (or third)(or fourth) on the Optional parameter feature.
If you want that then go to VB.Net, IMHO languages should be different not only by syntax, but features as well.
I understand that if Optional Parameter makes it easy to call out to COM which has optional parameters. If it can be done without Optional Parameters (which it can) then why introduce it in the first place. I can just see it bleeding beyond that. There will start to be C# methods defined with Optional Parameters. I can see this being used to making calls out to COM, but not used to define a C# methods with Optional Parameters (polymorphism). My hopes are that SytleCop, R#, or some other syntax code analyzer will spot c# methods defined with optional parameters and say no, no. Give us some Guidance on how and where it should be used. Similar to the misuse of generic methods and extensions are getting out of hand. I see more and more articles about the miss use of generic methods and extensions foo<t>() or foo(T object).
VB.Net is there for those who *think* doing something in C# is harder or takes more code and time. This is relative because what takes on person longer or more effort will take someone else less time and effort. If you want optional parameters then use VB.Net because not having them in C# is too difficult.
Similar issue as with optional parameter is with complex numbers. Now the line is blurred between c# and F#. If C# starts to have data types that F# has then why do I need F#? Why bloat C# with something that I can get with another language?

I used to be shocked at how hard java guys fought adding closures to the language, like it was the root of all evil because they weren't used to it. As of 3.5, c# people seem to be getting the same kind of blub programmer condition

var: in what world is ReallyReallyLongTypeName reallyReallyLongTypeName = new ReallyReallyLongTypeName() better then var variable = new ReallyReallyLongTypeName()? An argument can be made that var a = obtuseFunction() is a nono, and I would agree. But where I work has banned me from using var, and friends in other shops don't use var.

optional: how is overloads that pass null up to the more verbose functions clearer then default values? I have seen 7 overloads before, plus documentation, adding up to about 100 lines of pure noise. Do people just like typing, and boilerplate?

dynamic: you can introduce a really incredible amount of flexibility into a system with dynamic typing, I mean, eliminating entire layers of archetecture. There are definately cons around tooling and performance, but it is already commonly accepted that developer productivity often outweighs performance when it comes to technology and platforms. That is why we are using C# and not assembler.


I think the whole sky is falling mentality around these features is absolutely nuts, and shows a profound myopia in the people that are freaking out.

I'll end this with a quote from pg, one of the great hackers of our time that I think totally fits. Open your mind and learn more then one language, and don't be a blub programmer

"As long as our hypothetical Blub programmer is looking down the power continuum, he knows he's looking down. Languages less powerful than Blub are obviously less powerful, because they're missing some feature he's used to. But when our hypothetical Blub programmer looks in the other direction, up the power continuum, he doesn't realize he's looking up. What he sees are merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, because he thinks in Blub.
When we switch to the point of view of a programmer using any of the languages higher up the power continuum, however, we find that he in turn looks down upon Blub. How can you get anything done in Blub? It doesn't even have y.
By induction, the only programmers in a position to see all the differences in power between the various languages are those who understand the most powerful one. (This is probably what Eric Raymond meant about Lisp making you a better programmer.) You can't trust the opinions of the others, because of the Blub paradox: they're satisfied with whatever language they happen to use, because it dictates the way they think about programs."

hi,

First of all. Thanks very much for your useful post.

I just came across your blog and wanted to drop you a note telling you how impressed I was with the information you have posted here.

Please let me introduce you some info related to this post and I hope that it is useful for .Net community.

There is a good C# resource site, Have alook

http://www.csharptalk.com

simi

Programming languages should be simple to write and simple to read. c# is neither.

Various people all over the world receive the loans in various banks, because this is easy.