
Announcing .NET Core 1.1 - benaadams
https://blogs.msdn.microsoft.com/dotnet/2016/11/16/announcing-net-core-1-1/
======
brandur
Here's a pretty interesting note on .NET Core 1.1's performance improvements
from round 13 of Techempower's framework benchmarks [1] (linked from the
announcement above):

> Thanks to Microsoft’s herculean performance tuning effort, ASP.NET—in the
> new cross-platform friendly form of ASP.NET Core—is now a top performer in
> our Plaintext test, making it among the fastest platforms at the
> fundamentals of web request routing. The degree of improvement is absolutely
> astonishing, going from 2,120 requests per second on Mono in Round 11 to
> 1,822,366 requests per second on ASP.NET Core in Round 13. That’s an
> approximately 85,900% improvement, and that doesn’t even account for Round
> 11’s hardware being faster than our new hardware.

Here are the benchmarks in question [2].

There are a few caveats attached, like that it's still not quite at the top
and the best improvement is under the plaintext benchmark in particular, but
nonetheless a very impressive effort on the part of the .NET team.

[1] [https://www.techempower.com/blog/2016/11/16/framework-
benchm...](https://www.techempower.com/blog/2016/11/16/framework-benchmarks-
round-13/)

[2]
[https://www.techempower.com/benchmarks/#section=data-r13&hw=...](https://www.techempower.com/benchmarks/#section=data-r13&hw=ph&test=plaintext)

~~~
0xmohit

      TechEmpower also reports that the performance of ASP.NET Core
      running on Linux is approximately 760 times faster than it was
      one year ago.  Since TechEmpower started measuring benchmarks
      in March 2013, they have never seen such a performance
      improvement as they have observed in ASP.NET Core over the last
      year.

~~~
arenaninja
The pessimist's take: there was a lot to improve.

My exposure to C# and .NET is small enough that I'm not sure what this means
in terms of PHP. Is this like a PHP4 to PHP5.3 or more like PHP5 to PHP7
change?

~~~
phaed
PHP to Hack

------
skyde
Could someone explain why "ASP.NET Core 1.1" Kestrel webserver decided to use
LibUV DllImpor [1] instead of .NET Asynchronous Server Socket
(System.Net.Sockets) [2]. Does that mean that the managed implementation of
Async socket is broken and was too slow? [1]
"[https://github.com/aspnet/KestrelHttpServer/blob/dev/src/Mic...](https://github.com/aspnet/KestrelHttpServer/blob/dev/src/Mic..).
[2] [https://msdn.microsoft.com/en-
us/library/bew39x2a(v=vs.110)....](https://msdn.microsoft.com/en-
us/library/bew39x2a\(v=vs.110\)..).

~~~
halter73
It means that development on Kestrel started before work on making
System.Net.Sockets cross-platform was completed. The programming model for
libuv and .NET Sockets is different enough (mostly in terms of threading) to
make the transition non-trivial.

Some recent basic testing show .NET Sockets perform at least as well as libuv.
We are strongly considering transitioning Kestrel to Sockets at the same time
we migrate from Streams to Pipelines. [1] Pipelines are basically push based
Streams that require less total allocations to use. This is because Pipelines
allow better memory sharing between producers and consumers.

[1]
[https://github.com/dotnet/corefxlab/tree/master/src/System.I...](https://github.com/dotnet/corefxlab/tree/master/src/System.IO.Pipelines)

Disclosure: In case it wasn't already obvious, I work for Microsoft on
Kestrel.

~~~
simooooo
Are there any plans for RIO?

~~~
halter73
In the long term yes. When we switch to System.Net.Sockets it will be done
with an emphasis on transport agnosticism. [1]

ATM, it looks like Sockets will be the priority since it's a cross platform
API more similar to what libuv currently provides.

[1]
[https://github.com/aspnet/KestrelHttpServer/issues/828](https://github.com/aspnet/KestrelHttpServer/issues/828)

------
0xmohit
Half of HN front page today is Microsoft, .NET, Visual Studio, Connect.

~~~
arenaninja
Lots of news coming out of Microsoft's Connect event. C# is a great language,
.NET Core makes it available cross-platform, and now the tooling is being
announced (whether it's on par with what's available on Windows is TBD)

~~~
hnrodey
IMO The ecosystem of tools on Windows for C#/.NET is what makes it special
stack. Resharper and LinqPad are two notable tools that I consider vital to my
everyday workflow that just simply don't exist for macOS.

At home I use macOS primarily and I'm trying to ramp up on .NET Core for a few
personal projects and I'm having a tough time trying to find a suitable dev
environment that provides me with the same speed/comfort that I get on a
Windows machine and so far it's tough. Project Rider on macOS is coming along
nicely but that still leaves no LINQPad which is super handy for working on
small bits of code with near instant results. The feedback loop is so short
when using Linqpad it's insane.

~~~
mattmanser
You haven't needed linqpad since vs 2015, which has a C# repl in it.

I also don't get the point of resharper. Apart from being slow as molasses,
it's ridiculously over opinionated to the point where is makes existing code a
mess of squiggles. And it's intellisense is super dumb as it redlines while
you're still typing, which is very distracting.

The only great part of it, the quick find, is now in vs 2015. Ctrl-,. I think
it literally just came in with the last patch.

~~~
hnrodey
I wasn't aware of the enhancement in VS2015. I'll definitely look at that
functionality.

VS2015 has made up a lot of ground for what R# lacked but the static analysis
still isn't there. You have to learn what errors/notes mean and how to
interpret the results because they are very meaningful. Point blank - writing
code _with_ Resharper will lead to higher quality code.

And yeah, some part of my Resharper love is just an old habit. I've been using
R# since VS2005 when the IDE lacked a lot of critical features that R#
plugged. Now a lot of it is just habits and keyboard shortcuts and it's only a
few hundred dollars for a license which still pays for itself throughout the
course of the year.

~~~
mattmanser
I simply disagree about higher quality code. One of my junior colleagues once
did a "let's apply a bunch of resharper recommendations". It was not pretty.
Its suggestions are almost always pedantic and puerile that don't improve code
quality in any meaningful way, at least in the out-of-the-box config.

It's nice when it picks up some stupidity like an always false condition, but
the out-of-the-box instance has so many stupid rules that after turning more
and more off it off, I gave up on it.

And this isn't the first time I've given it a go.

------
mmanfrin
I have never developed outside of OSX/Linux. My languages are Ruby,
Javascript, and the things in that domain. Can someone ELIaRubyDev what .NET
is? I used to think it was a language, but I've since been told that the
language I think of as ".Net" is actually C#.

~~~
hebrewhammer
.Net is both a run time and an echo system. C# is one of several programming
languages (VB, F#) that get compiled into CIL (common intermediate language)
and executed on the .Net run time CLR (common language runtime). Think of Java
being compiled and executed on the JVM (java virtual machine).

------
tree_of_item
Ok, it's another release so let me ask this again: can you manage .NET
projects _without_ dealing with an IDE like Visual Studio or MonoDevelop or
whatever? And for whatever solution you recommend, do people actually _use_ it
in the wild or is it just a technical preview thing?

I'm really looking for something like `cargo build` or `go build`, but it
looks like .NET just loves their IDEs and XML based configuration files.

~~~
ungzd
I used xbuild, but from Mono, not .NET Core (maybe .NET Core has it too). It
builds standard Visual Studio 'msbuild' files (.sln, .csproj, .fsproj). It
works okay and these XML files are editable by hand but still somewhat creepy.
I tried only F# so I used .fsproj build files and was able to do everything
even without Visual Studio Code (in Emacs).

There's also tools called Paket and Fake which look like .NET counterparts of
Ruby's Bundler and Rake, created by F# community. Paket patches
.fsproj/.csproj files and it looks like hack but still better than putting
absolute paths to preinstalled dependencies.

For creating new projects from template, Yeoman (installable from npm) is
quite popular.

Build process in .NET looks like is in transitional state from Visual Studio-
first to build tools-first and is still painful and confusing. I didn't try
project.json / dotnet tooling yet, because F# website doesn't mention it. I
tried only F# and Monogame.

~~~
enricosada
Good blog post as intro "F# Suave app on dotnet core on Kubernetes on Google
Cloud"

That's f# and .NET Core console app (who host suave web), published in a
docker container and run on k8 on google cloud

[http://blog.2mas.xyz/fsharp-suave-app-on-dotnet-core-on-
kube...](http://blog.2mas.xyz/fsharp-suave-app-on-dotnet-core-on-kubernetes-
on-google-cloud/)

------
TACIXAT
Was really hoping for System.DirectoryServices in this release but they pushed
it to 1.2.

