Microsoft now giving away VS 2013

Paulo Pinto via Digitalmars-d digitalmars-d at puremagic.com
Fri Nov 14 02:48:07 PST 2014


On Thursday, 13 November 2014 at 23:29:42 UTC, ZombineDev wrote:
> Well D is still a much better language. I have used C# 
> professionally for about 2 years and in my opinion it invites 
> writing over-architected OOP with little regard about 
> efficiency. My experience is based on working in the code-base 
> of my old job, reading forums, books and so on.
>
> Just look at these "beautiful" pieces of art:
>
> http://referencesource.microsoft.com/#PresentationFramework/Framework/System/Windows/Controls/DataGrid.cs
> ^ just try to find were the performance bottleneck is and 
> refactor it :D


I have an application fetching thousands of rows from an Oracle 
database and displaying it under a few ms.

It is fast enough.

If I really need to find a performance bottleneck there lots of 
visual profiling tools available.

>
> And some other elegant pieces:
> https://github.com/dotnet/corefx/blob/master/src/System.Numerics.Vectors/src/System/Numerics/Register.cs
>
> https://github.com/dotnet/corefx/blob/master/src/System.Numerics.Vectors/src/System/Numerics/Vector.cs
>
> ^ Without templates and CTFE the power to weight ratio is 
> pretty low.

Reflection, dynamic and attributes are also quite powerful 
meta-programming capabilities.

As far as I can tell, D code still doesn't explore UDA that much.

>
> Of course there are exceptions to the rule. Here is a somewhat 
> large, performance oriented project. This an open-source 
> implementation of the classic C&C RTS games:
> https://github.com/OpenRA/OpenRA
>
> I really don't want to go back to .NET. It's not about that 
> Microsoft is evil, anti-FOSS or anything like that.
> I just really like the way D allows me to express my intent and 
> how flexible it is. It is the overall feeling I get from the 
> community that people want to use D to write elegant, yet 
> highly optimal code. And when there is a problem preventing 
> this (like for some people the GC) a great effort is made to 
> improve the situation (e.g. http://wiki.dlang.org/DIPs, etc. )
>
> My impression is that the average .net developer is scared by 
> the "low-level stuff" and wants these stuff to be magically 
> taken care of. I haven't seen anyone that wants to get rid of 
> the GC and even fewer are trying to be proactive and to find a 
> solution (like @nogc, RC strings or exceptions in Dland).

Why should .NET get rid of the GC?

It has quite good performance, better than the one D has, and the
new one will be even better.

Can scale from embedded platforms like Netduino up to Azure scale 
cloud deployments for games like Age of Ascent or companies of 
Lufthansa scale.

You can use manual memory management in .NET if you really want 
to, via struts, unsafe, fixed allocations or just direct calling 
Windows APIs via P/Invoke.

What matters is business value from code, not how beautiful it is.

This is why, regardless how primitive Go might be, it is being 
picked up by many companies.

It is primitive compared to modern language standards, but 
companies see business value in it. Even Microsoft has joined the 
party with Azure support for Docker.

Guess in what language the integration is being made?

>
> Also a large portion C# devs are highly dependent on 
> Microsoft's politics. Like when the development of Silverlight  
> platform was canceled. It was a huge blow to the .NET community 
> and there was no solution (even third-party) so everyone just 
> the left the sinking ship.

You are always dependent on the politics of whoever develops your 
tools, regardless of the community or company.

Lots of examples both in commercial and open source worlds.

The only way around it is if you build your complete stack (OS + 
language + libraries) yourself.

--
Paulo






More information about the Digitalmars-d mailing list