Bruno Medeiros escribió:
> Ary Borenszweig wrote:
>> Robert Fraser escribió:
>>> Denis Koroskin wrote:
>>>> I once had the following Color class:
>>>>
>>>> class Color
>>>> {
>>>>     this (byte alpha, byte red, byte green, byte blue) { ... }
>>>> }
>>>>
>>>> and used it as follows:
>>>>
>>>> Color c = new Color(255, 0, 255, 0); // opaque green color
>>>>
>>>> After refactoring, alpha became last argument in ctor:
>>>>
>>>>     this(byte red, byte green, byte blue, byte alpha) { ... }
>>>>
>>>> Note that this change didn't raise any compilation error, nothing that would notify my of possible error.
>>>>
>>>> Needless to say that I didn't enjoy searching all the code that used Color to reorder parameters (although some artifact were nice :)
>>>> It would save me quite some time if I initialized all my instances as follows:
>>>>
>>>> Color c = new Color(alpha: 255, red: 0, green: 255, blue: 0);
>>>>
>>>> Now compiler could raise an error if parameters order was changed. Even better - compiler could reorder parameters for me automatically if given that all of them are specified and no params ommited (unlike Python). This makes code more robust to refactoring.
>>>
>>> The first thing  I thought of when reading this is Eclipse JDT's "Change Method Signature" refactoring that will look up all the calls in your project & automatically reorder the parameters for you.
>>
>> Me too. :-)
> 
> Of course I also ate a piece of that cake. ^^
> 
> I keep getting the impression that we 3 are the only people in the D NG that have used JDT extensively.
> That's unfortunate because I feel most people here don't realize how much an IDE like JDT (or something comparable, like IntelliJ IDEA, but not VS) can shape and improve the development workflow (and thus have potential implications in language design).
> And it's not something that can be easily understood in foresight - one really has to try it out (rich IDE functionality) for some time and even then, you might not notice it until it is *taken* from you. Fun story, that happened to me:
> 
> When I started looking for work after graduation, recruiters asked me if I had preference for working with C# or Java. I had no anti-Microsoft bias (apparently some people do, even in the workplace), so I judged both in terms of language only, and I really didn't have much of a preference then (note, this was considering C# only up to version 2.0 only). I was slightly inclined to Java, but only because I had used it more.
> But months later, when I started working on a project that had a desktop client, I tried using C# (to take advantage of the WinForms designer) I was vexed as Visual Studio (C# 2005) seemed primitive in comparison. Suddenly many of the things I had taken from granted were gone, and I missed them a lot more than I expected (one example is the Ctrl-1 "Assign to Local Variable" refactoring which gradually become one of my most used refactoring, almost as much as Refactor-Rename).

I recently discovered you can do the same with Ctrl+2, L :-)

Of course in D that'll be

auto whatever = <your expression here>;

Do here's a clear example where a language helps not being repetitive, and that kind of shortcut becomes less useful.

But refactoring is an essential thing in TDD, and I think that can't be easily supported by any language without using a proper IDE.

I also have the sensation we are the only guys that used JDT. In my workplace everyone feels very, very comfortable using Java; not because of the language itself, but because of Eclipse. It's amazing the speed boost you get once you get used to it. You don't have to look at external documentation files, you don't have to read someone else's code to understand what's going on. You don't need to remember lots of names, where's everything is located.

But, as Bruno says, you can't really feel it unless you try it.

"Ary Borenszweig" <ary@esperanto.org.ar> wrote in message news:gf03qh$23sg$1@digitalmars.com...
> Bruno Medeiros escribió:
>> Ary Borenszweig wrote:
>>> Robert Fraser escribió:
>>>> Denis Koroskin wrote:
>>>>> I once had the following Color class:
>>>>>
>>>>> class Color
>>>>> {
>>>>>     this (byte alpha, byte red, byte green, byte blue) { ... }
>>>>> }
>>>>>
>>>>> and used it as follows:
>>>>>
>>>>> Color c = new Color(255, 0, 255, 0); // opaque green color
>>>>>
>>>>> After refactoring, alpha became last argument in ctor:
>>>>>
>>>>>     this(byte red, byte green, byte blue, byte alpha) { ... }
>>>>>
>>>>> Note that this change didn't raise any compilation error, nothing that would notify my of possible error.
>>>>>
>>>>> Needless to say that I didn't enjoy searching all the code that used
>>>>> Color to reorder parameters (although some artifact were nice :)
>>>>> It would save me quite some time if I initialized all my instances as
>>>>> follows:
>>>>>
>>>>> Color c = new Color(alpha: 255, red: 0, green: 255, blue: 0);
>>>>>
>>>>> Now compiler could raise an error if parameters order was changed. Even better - compiler could reorder parameters for me automatically if given that all of them are specified and no params ommited (unlike Python). This makes code more robust to refactoring.
>>>>
>>>> The first thing  I thought of when reading this is Eclipse JDT's "Change Method Signature" refactoring that will look up all the calls in your project & automatically reorder the parameters for you.
>>>
>>> Me too. :-)
>>
>> Of course I also ate a piece of that cake. ^^
>>
>> I keep getting the impression that we 3 are the only people in the D NG
>> that have used JDT extensively.
>> That's unfortunate because I feel most people here don't realize how much
>> an IDE like JDT (or something comparable, like IntelliJ IDEA, but not VS)
>> can shape and improve the development workflow (and thus have potential
>> implications in language design).
>> And it's not something that can be easily understood in foresight - one
>> really has to try it out (rich IDE functionality) for some time and even
>> then, you might not notice it until it is *taken* from you. Fun story,
>> that happened to me:
>>
>> When I started looking for work after graduation, recruiters asked me if
>> I had preference for working with C# or Java. I had no anti-Microsoft
>> bias (apparently some people do, even in the workplace), so I judged both
>> in terms of language only, and I really didn't have much of a preference
>> then (note, this was considering C# only up to version 2.0 only). I was
>> slightly inclined to Java, but only because I had used it more.
>> But months later, when I started working on a project that had a desktop
>> client, I tried using C# (to take advantage of the WinForms designer) I
>> was vexed as Visual Studio (C# 2005) seemed primitive in comparison.
>> Suddenly many of the things I had taken from granted were gone, and I
>> missed them a lot more than I expected (one example is the Ctrl-1 "Assign
>> to Local Variable" refactoring which gradually become one of my most used
>> refactoring, almost as much as Refactor-Rename).
>
> I recently discovered you can do the same with Ctrl+2, L :-)
>
> Of course in D that'll be
>
> auto whatever = <your expression here>;
>
> Do here's a clear example where a language helps not being repetitive, and that kind of shortcut becomes less useful.
>
> But refactoring is an essential thing in TDD, and I think that can't be easily supported by any language without using a proper IDE.
>
> I also have the sensation we are the only guys that used JDT. In my workplace everyone feels very, very comfortable using Java; not because of the language itself, but because of Eclipse. It's amazing the speed boost you get once you get used to it. You don't have to look at external documentation files, you don't have to read someone else's code to understand what's going on. You don't need to remember lots of names, where's everything is located.
>
> But, as Bruno says, you can't really feel it unless you try it.

I used Eclipse constantly back when I was working with Java (before I discovered C# and then D). And before that, I was a huge Visual Studio fan from version 5 through the early .NET versions. But ever since leaving Java, I've been finding myself deliberately avoiding Eclipse just because I'd much rather use an IDE that's responsive (and not so heavly Java-centric) than one that has a few extra bells and whistles. Don't get me wrong, I love IDE bells and whistles (that's why I used to be such a Visual Studio fan, and used Eclipse when I switched to Java), but when trying to interact with the IDE starts to feel like running through knee-deep molasses, as it frequently does with Eclipse, it's just not worth it to me.

Nick Sabalausky wrote:
> "Ary Borenszweig" <ary@esperanto.org.ar> wrote in message news:gf03qh$23sg$1@digitalmars.com...
>> Bruno Medeiros escribió:
>>> Ary Borenszweig wrote:
>>>> Robert Fraser escribió:
>>>>> Denis Koroskin wrote:
>>>>>> I once had the following Color class:
>>>>>>
>>>>>> class Color
>>>>>> {
>>>>>>     this (byte alpha, byte red, byte green, byte blue) { ... }
>>>>>> }
>>>>>>
>>>>>> and used it as follows:
>>>>>>
>>>>>> Color c = new Color(255, 0, 255, 0); // opaque green color
>>>>>>
>>>>>> After refactoring, alpha became last argument in ctor:
>>>>>>
>>>>>>     this(byte red, byte green, byte blue, byte alpha) { ... }
>>>>>>
>>>>>> Note that this change didn't raise any compilation error, nothing that would notify my of possible error.
>>>>>>
>>>>>> Needless to say that I didn't enjoy searching all the code that used Color to reorder parameters (although some artifact were nice :)
>>>>>> It would save me quite some time if I initialized all my instances as follows:
>>>>>>
>>>>>> Color c = new Color(alpha: 255, red: 0, green: 255, blue: 0);
>>>>>>
>>>>>> Now compiler could raise an error if parameters order was changed. Even better - compiler could reorder parameters for me automatically if given that all of them are specified and no params ommited (unlike Python). This makes code more robust to refactoring.
>>>>> The first thing  I thought of when reading this is Eclipse JDT's "Change Method Signature" refactoring that will look up all the calls in your project & automatically reorder the parameters for you.
>>>> Me too. :-)
>>> Of course I also ate a piece of that cake. ^^
>>>
>>> I keep getting the impression that we 3 are the only people in the D NG that have used JDT extensively.
>>> That's unfortunate because I feel most people here don't realize how much an IDE like JDT (or something comparable, like IntelliJ IDEA, but not VS) can shape and improve the development workflow (and thus have potential implications in language design).
>>> And it's not something that can be easily understood in foresight - one really has to try it out (rich IDE functionality) for some time and even then, you might not notice it until it is *taken* from you. Fun story, that happened to me:
>>>
>>> When I started looking for work after graduation, recruiters asked me if I had preference for working with C# or Java. I had no anti-Microsoft bias (apparently some people do, even in the workplace), so I judged both in terms of language only, and I really didn't have much of a preference then (note, this was considering C# only up to version 2.0 only). I was slightly inclined to Java, but only because I had used it more.
>>> But months later, when I started working on a project that had a desktop client, I tried using C# (to take advantage of the WinForms designer) I was vexed as Visual Studio (C# 2005) seemed primitive in comparison. Suddenly many of the things I had taken from granted were gone, and I missed them a lot more than I expected (one example is the Ctrl-1 "Assign to Local Variable" refactoring which gradually become one of my most used refactoring, almost as much as Refactor-Rename).
>> I recently discovered you can do the same with Ctrl+2, L :-)
>>
>> Of course in D that'll be
>>
>> auto whatever = <your expression here>;
>>
>> Do here's a clear example where a language helps not being repetitive, and that kind of shortcut becomes less useful.
>>
>> But refactoring is an essential thing in TDD, and I think that can't be easily supported by any language without using a proper IDE.
>>
>> I also have the sensation we are the only guys that used JDT. In my workplace everyone feels very, very comfortable using Java; not because of the language itself, but because of Eclipse. It's amazing the speed boost you get once you get used to it. You don't have to look at external documentation files, you don't have to read someone else's code to understand what's going on. You don't need to remember lots of names, where's everything is located.
>>
>> But, as Bruno says, you can't really feel it unless you try it.
> 
> I used Eclipse constantly back when I was working with Java (before I discovered C# and then D). And before that, I was a huge Visual Studio fan from version 5 through the early .NET versions. But ever since leaving Java, I've been finding myself deliberately avoiding Eclipse just because I'd much rather use an IDE that's responsive (and not so heavly Java-centric) than one that has a few extra bells and whistles. Don't get me wrong, I love IDE bells and whistles (that's why I used to be such a Visual Studio fan, and used Eclipse when I switched to Java), but when trying to interact with the IDE starts to feel like running through knee-deep molasses, as it frequently does with Eclipse, it's just not worth it to me. 
> 
> 

Well, I'm not sure if that was your case, but if we are talking web development (something I did in my job), then the Java web development component of Eclipse (WTP, which extends JDT), is noticeably slow and somewhat unstable on several parts. It really isn't up to par to basic JDT, which is much more mature, although WTP has been improving lately. I don't know how it compares to Visual Studio since I never did any C# web development, only core C#.

-- 
Bruno Medeiros - Software Developer, MSc. in CS/E graduate
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D

Ary Borenszweig wrote:
> Bruno Medeiros escribió:
>> Ary Borenszweig wrote:
>>> Robert Fraser escribió:
>>>> Denis Koroskin wrote:
>>>>> I once had the following Color class:
>>>>>
>>>>> class Color
>>>>> {
>>>>>     this (byte alpha, byte red, byte green, byte blue) { ... }
>>>>> }
>>>>>
>>>>> and used it as follows:
>>>>>
>>>>> Color c = new Color(255, 0, 255, 0); // opaque green color
>>>>>
>>>>> After refactoring, alpha became last argument in ctor:
>>>>>
>>>>>     this(byte red, byte green, byte blue, byte alpha) { ... }
>>>>>
>>>>> Note that this change didn't raise any compilation error, nothing that would notify my of possible error.
>>>>>
>>>>> Needless to say that I didn't enjoy searching all the code that used Color to reorder parameters (although some artifact were nice :)
>>>>> It would save me quite some time if I initialized all my instances as follows:
>>>>>
>>>>> Color c = new Color(alpha: 255, red: 0, green: 255, blue: 0);
>>>>>
>>>>> Now compiler could raise an error if parameters order was changed. Even better - compiler could reorder parameters for me automatically if given that all of them are specified and no params ommited (unlike Python). This makes code more robust to refactoring.
>>>>
>>>> The first thing  I thought of when reading this is Eclipse JDT's "Change Method Signature" refactoring that will look up all the calls in your project & automatically reorder the parameters for you.
>>>
>>> Me too. :-)
>>
>> Of course I also ate a piece of that cake. ^^
>>
>> I keep getting the impression that we 3 are the only people in the D NG that have used JDT extensively.
>> That's unfortunate because I feel most people here don't realize how much an IDE like JDT (or something comparable, like IntelliJ IDEA, but not VS) can shape and improve the development workflow (and thus have potential implications in language design).
>> And it's not something that can be easily understood in foresight - one really has to try it out (rich IDE functionality) for some time and even then, you might not notice it until it is *taken* from you. Fun story, that happened to me:
>>
>> When I started looking for work after graduation, recruiters asked me if I had preference for working with C# or Java. I had no anti-Microsoft bias (apparently some people do, even in the workplace), so I judged both in terms of language only, and I really didn't have much of a preference then (note, this was considering C# only up to version 2.0 only). I was slightly inclined to Java, but only because I had used it more.
>> But months later, when I started working on a project that had a desktop client, I tried using C# (to take advantage of the WinForms designer) I was vexed as Visual Studio (C# 2005) seemed primitive in comparison. Suddenly many of the things I had taken from granted were gone, and I missed them a lot more than I expected (one example is the Ctrl-1 "Assign to Local Variable" refactoring which gradually become one of my most used refactoring, almost as much as Refactor-Rename).
> 
> I recently discovered you can do the same with Ctrl+2, L :-)
> 
> Of course in D that'll be
> 
> auto whatever = <your expression here>;
> 
> Do here's a clear example where a language helps not being repetitive, and that kind of shortcut becomes less useful.
> 
> But refactoring is an essential thing in TDD, and I think that can't be easily supported by any language without using a proper IDE.
> 
> I also have the sensation we are the only guys that used JDT. In my workplace everyone feels very, very comfortable using Java; not because of the language itself, but because of Eclipse. It's amazing the speed boost you get once you get used to it. You don't have to look at external documentation files, you don't have to read someone else's code to understand what's going on. You don't need to remember lots of names, where's everything is located.
> 

"you don't have to read someone else's code to understand what's going on." - Hum, I agree with the rest of what you said, but not necessarily on this one. In fact I do a lot of "browsing" with Eclipse (Ctrl-click, Open Type, etc.), in order to read other's code.

-- 
Bruno Medeiros - Software Developer, MSc. in CS/E graduate
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D

bearophile wrote:
> Thanks to Reddit I have found a nice short document that lists some of the differences of C#4:
> https://docs.google.com/View?docid=dcj4xk6_17ffc7nmgv
> 

Hum, interesting how they tackled the covariance/contravariance problem in generics parameters. It's not as powerful as Java's generics (in Java you can have covariance and contravariance in a List-like interface), but it's also quite simpler, so it's an interesting compromise.

Hum, I wonder if we can implement a system anywhere like Java's generics in D. Could be possible, when we have opImplicitCast.

> They have added a dynamic invocation, useful if you want to implement a dynamic language (like IronPython, IronRuby, etc) on top of the dotnet. Object-C shows this is doable in a very C-like language, and the Boo language shows that in a statically typed language it can be useful to use a Duck type once in a while to reduce the "static type pressure". More info on this last concept in the Boo site.
> 

I'm usually quite a fan of hard, disciplined, static typing, but it's an interesting idea nonetheless. Wonder if it would be worth putting into D.

-- 
Bruno Medeiros - Software Developer, MSc. in CS/E graduate
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D

"Bruno Medeiros" <brunodomedeiros+spam@com.gmail> wrote in message news:gf1tci$2s5o$1@digitalmars.com...
> Nick Sabalausky wrote:
>> "Ary Borenszweig" <ary@esperanto.org.ar> wrote in message news:gf03qh$23sg$1@digitalmars.com...
>>> Bruno Medeiros escribió:
>>>> Ary Borenszweig wrote:
>>>>> Robert Fraser escribió:
>>>>>> Denis Koroskin wrote:
>>>>>>> I once had the following Color class:
>>>>>>>
>>>>>>> class Color
>>>>>>> {
>>>>>>>     this (byte alpha, byte red, byte green, byte blue) { ... }
>>>>>>> }
>>>>>>>
>>>>>>> and used it as follows:
>>>>>>>
>>>>>>> Color c = new Color(255, 0, 255, 0); // opaque green color
>>>>>>>
>>>>>>> After refactoring, alpha became last argument in ctor:
>>>>>>>
>>>>>>>     this(byte red, byte green, byte blue, byte alpha) { ... }
>>>>>>>
>>>>>>> Note that this change didn't raise any compilation error, nothing that would notify my of possible error.
>>>>>>>
>>>>>>> Needless to say that I didn't enjoy searching all the code that used
>>>>>>> Color to reorder parameters (although some artifact were nice :)
>>>>>>> It would save me quite some time if I initialized all my instances
>>>>>>> as follows:
>>>>>>>
>>>>>>> Color c = new Color(alpha: 255, red: 0, green: 255, blue: 0);
>>>>>>>
>>>>>>> Now compiler could raise an error if parameters order was changed. Even better - compiler could reorder parameters for me automatically if given that all of them are specified and no params ommited (unlike Python). This makes code more robust to refactoring.
>>>>>> The first thing  I thought of when reading this is Eclipse JDT's "Change Method Signature" refactoring that will look up all the calls in your project & automatically reorder the parameters for you.
>>>>> Me too. :-)
>>>> Of course I also ate a piece of that cake. ^^
>>>>
>>>> I keep getting the impression that we 3 are the only people in the D NG
>>>> that have used JDT extensively.
>>>> That's unfortunate because I feel most people here don't realize how
>>>> much an IDE like JDT (or something comparable, like IntelliJ IDEA, but
>>>> not VS) can shape and improve the development workflow (and thus have
>>>> potential implications in language design).
>>>> And it's not something that can be easily understood in foresight - one
>>>> really has to try it out (rich IDE functionality) for some time and
>>>> even then, you might not notice it until it is *taken* from you. Fun
>>>> story, that happened to me:
>>>>
>>>> When I started looking for work after graduation, recruiters asked me
>>>> if I had preference for working with C# or Java. I had no
>>>> anti-Microsoft bias (apparently some people do, even in the workplace),
>>>> so I judged both in terms of language only, and I really didn't have
>>>> much of a preference then (note, this was considering C# only up to
>>>> version 2.0 only). I was slightly inclined to Java, but only because I
>>>> had used it more.
>>>> But months later, when I started working on a project that had a
>>>> desktop client, I tried using C# (to take advantage of the WinForms
>>>> designer) I was vexed as Visual Studio (C# 2005) seemed primitive in
>>>> comparison. Suddenly many of the things I had taken from granted were
>>>> gone, and I missed them a lot more than I expected (one example is the
>>>> Ctrl-1 "Assign to Local Variable" refactoring which gradually become
>>>> one of my most used refactoring, almost as much as Refactor-Rename).
>>> I recently discovered you can do the same with Ctrl+2, L :-)
>>>
>>> Of course in D that'll be
>>>
>>> auto whatever = <your expression here>;
>>>
>>> Do here's a clear example where a language helps not being repetitive, and that kind of shortcut becomes less useful.
>>>
>>> But refactoring is an essential thing in TDD, and I think that can't be easily supported by any language without using a proper IDE.
>>>
>>> I also have the sensation we are the only guys that used JDT. In my workplace everyone feels very, very comfortable using Java; not because of the language itself, but because of Eclipse. It's amazing the speed boost you get once you get used to it. You don't have to look at external documentation files, you don't have to read someone else's code to understand what's going on. You don't need to remember lots of names, where's everything is located.
>>>
>>> But, as Bruno says, you can't really feel it unless you try it.
>>
>> I used Eclipse constantly back when I was working with Java (before I discovered C# and then D). And before that, I was a huge Visual Studio fan from version 5 through the early .NET versions. But ever since leaving Java, I've been finding myself deliberately avoiding Eclipse just because I'd much rather use an IDE that's responsive (and not so heavly Java-centric) than one that has a few extra bells and whistles. Don't get me wrong, I love IDE bells and whistles (that's why I used to be such a Visual Studio fan, and used Eclipse when I switched to Java), but when trying to interact with the IDE starts to feel like running through knee-deep molasses, as it frequently does with Eclipse, it's just not worth it to me.
>
> Well, I'm not sure if that was your case, but if we are talking web development (something I did in my job), then the Java web development component of Eclipse (WTP, which extends JDT), is noticeably slow and somewhat unstable on several parts. It really isn't up to par to basic JDT, which is much more mature, although WTP has been improving lately. I don't know how it compares to Visual Studio since I never did any C# web development, only core C#.
>

I've done a lot of web work, but none of the Java work I've done was web (at least not server-side anyway). The was just normal ordinary Java applications, command-line and GUI, and the occasional embedded applet. The .NET versions of Visual Studio have, unfortunately, been getting increasingly boated, but in my experience, Eclipse is still more boated. Although, I can't say much about Visual Studio's web stuff. The last time I used Visual Studio for web, it was still called InterDev.

Bruno Medeiros wrote:
> Ary Borenszweig wrote:
>> Robert Fraser escribió:
>>> Denis Koroskin wrote:
>>>> I once had the following Color class:
>>>>
>>>> class Color
>>>> {
>>>>     this (byte alpha, byte red, byte green, byte blue) { ... }
>>>> }
>>>>
>>>> and used it as follows:
>>>>
>>>> Color c = new Color(255, 0, 255, 0); // opaque green color
>>>>
>>>> After refactoring, alpha became last argument in ctor:
>>>>
>>>>     this(byte red, byte green, byte blue, byte alpha) { ... }
>>>>
>>>> Note that this change didn't raise any compilation error, nothing that would notify my of possible error.
>>>>
>>>> Needless to say that I didn't enjoy searching all the code that used Color to reorder parameters (although some artifact were nice :)
>>>> It would save me quite some time if I initialized all my instances as follows:
>>>>
>>>> Color c = new Color(alpha: 255, red: 0, green: 255, blue: 0);
>>>>
>>>> Now compiler could raise an error if parameters order was changed. Even better - compiler could reorder parameters for me automatically if given that all of them are specified and no params ommited (unlike Python). This makes code more robust to refactoring.
>>>
>>> The first thing  I thought of when reading this is Eclipse JDT's "Change Method Signature" refactoring that will look up all the calls in your project & automatically reorder the parameters for you.
>>
>> Me too. :-)
> 
> Of course I also ate a piece of that cake. ^^
> 
> I keep getting the impression that we 3 are the only people in the D NG that have used JDT extensively.
> That's unfortunate because I feel most people here don't realize how much an IDE like JDT (or something comparable, like IntelliJ IDEA, but not VS) can shape and improve the development workflow (and thus have potential implications in language design).

I haven't used JDT very much -- I can't stand the standard library in Java, so I try to avoid it.

I've used Visual Studio with Resharper. From what I've seen, Resharper is much better than JDT. It might just be a matter of default configurations, but that's still a strong advantage.

Still, Resharper costs $250 on top of the cost of Visual Studio, and it won't work with the free versions of VS.

However, when working with C# on a large codebase, I'm significantly faster when working with Resharper. Enough so that if Resharper is not functioning, getting it in working order is my top priority.

The nestable object literal syntax obsoletes some cases where constructutors were used before, and where named arguments would be used, but clearly not all (deterministic initialization) - it can be used to initialize properties via new Person() { First = "Bob", Last = "Smith" }; I can't remember the exact syntax.

- Bent

"bearophile" <bearophileHUGS@lycos.com> skrev i meddelelsen news:ge9sf5$1vdc$1@digitalmars.com...
> Thanks to Reddit I have found a nice short document that lists some of the differences of C#4:
> https://docs.google.com/View?docid=dcj4xk6_17ffc7nmgv
>
> They have added a dynamic invocation, useful if you want to implement a dynamic language (like IronPython, IronRuby, etc) on top of the dotnet. Object-C shows this is doable in a very C-like language, and the Boo language shows that in a statically typed language it can be useful to use a Duck type once in a while to reduce the "static type pressure". More info on this last concept in the Boo site.
>
> Something that I like a lot is the named arguments, that I hope to see in D and Delight someday. They are used often in Python, and they help increase the readability of the code, sometimes even reducing mistakes.
> They have used colons:
> foo(x: 1, z: 3)
> While Python uses equal signs:
> foo(x=1, z=3)
> I think they are about equally readable.
> (I think there's a problem with named arguments, that you can solve in some ways, for example with an extra hidden bitfield argument that encodes what arguments are given and what not).
>
> Bye,
> bearophile