
.NET Core Roadmap - jackfoxy
https://github.com/dotnet/core/blob/master/roadmap.md
======
dvcc
.NET Core really needs to figure out how to become somewhat accessible. I
(.NET <= 4.6 developer as my day job) recently tried to setup a new project
after it hit 1.0 and I was extremely disappointed.

The first step was to create a new project, okay cool. `dotnet new MyProject`
-- oh wait I want it to be a class library. Let's see `dotnet --help`, hmm I
don't see an option (at least not when I tried). Oh `dotnet new MyProject -t
lib`, of course!

Okay lets add xUnit and xUnit-runner. There is no simple command line utilty
that I saw to add them, so I have to manually edit the project.json file (wait
isn't this supposed to be csproj again?). Oh wait there are weird
compatibility issues between all the .NET Core versions, I have to manually go
look it up on the xUnit page ([https://xunit.github.io/docs/getting-started-
dotnet-core.htm...](https://xunit.github.io/docs/getting-started-dotnet-
core.html)). Okay I have the correct version listed, let's run my first test.

Error... Oh the created class library is targeting netstandard15, which I
thought was all I needed? I need to add netcore50. Some other unexplained
error occurred and I gave up for the time being. Yea maybe I could have sat
through it an persevered, but why should I? Why should it all be so
complicated and require two different frameworks _just_ to get a small class
library and a test project going.

Was I using it wrong? Most likely, but oh well. It was frustrating enough for
me to just not continue with it. .NET Core fatigue feels more real than
JavaScript fatigue.

~~~
jongalloway2
I'd recommend using the tutorials rather than just typing stuff and seeing
what happens. The language and concepts are the same, but there are some big
differences at the framework and platform level.

The xUnit tutorial is here:
[https://www.microsoft.com/net/tutorials/csharp/getting-
start...](https://www.microsoft.com/net/tutorials/csharp/getting-
started/testing)

Those tutorials are pretty intro level, but they do cover some of the issues
you ran into.

Also, I'd recommend checking out the new Visual Studio 2017 RC with updated
.NET Core tools and support for the csproj based projects:
[https://blogs.msdn.microsoft.com/dotnet/2016/12/12/updating-...](https://blogs.msdn.microsoft.com/dotnet/2016/12/12/updating-
visual-studio-2017-rc-net-core-tooling-improvements/)

~~~
dvcc
I just took a brief look at the tutorial and it would still get me caught up
on the same issues. The class library created by `dotnet new -t lib` had a
different target framework than most tutorials, and short of just copying and
pasting in a whole new project.json file (which changes the target framework
and imports two more) I am out of luck. It's pretty confusing and tiring!

~~~
jongalloway2
In Visual Studio 2017 RC it's "File / New / xUnit Test Project" and you're all
set.

I think some of the docs and presentations have gone a little far to the
everything-commandline direction. If you're an experienced .NET dev, you're
probably going to be a lot more comfortable with Visual Studio at least to get
started. Much easier to start with some working code and break it / play with
it than to start at the command line and a project file... again, if you're an
experienced .NET dev who's used to Visual Studio.

I will agree with your main point that it is confusing and that it should be
easier. Those are actually some of the top things listed on the roadmap.

~~~
dvcc
Admittedly, I would be much better off using VS to create the project/install
packages/etc but I thought I no longer needed to, hell they were providing
yeoman generators for .NET Core (but they weren't always updated at the same
time as a new release)!

------
pmnp
.NET Core has been a bittersweet experience. At one angle the ideals behind
.NET Core are fantastic and it will open up C# to become ubiquitous like Java.
On the other hand, their development process makes me want to throw it back at
Microsoft. Developers were allowed to head up into their ivory towers. Even to
this day they're coming up with ways to explain how the "tooling" is still
beta or broken. The .NET Core developers obviously just cared about the fun
internal stuff and left us to handle the ugly, real world stuff ourselves. If
they cared, they would have built tooling alongside the framework.

It has been almost six months since the .NET Core release and we still don't
have the "proper" tooling. They haven't done SignalR either. I've never been
held in limbo for so long. The only reason I'm hanging on is because of C# and
Visual Studio.

I don't even know what the significance of the ".NET Core 2.0" or ".NET
Standard 2.0" releases are anymore, the amount of complexity added to the
development decision making process in .NET Core got out of hand many months
ago. I'm not the only serious .NET developer who is feeling puzzled about the
purpose of all this. Sure, it was an interesting idea, but man the execution
could have been better.

~~~
mattchamb
I feel the same. Even as a .net developer, I'm really struggling to care about
.NET Core. My experiences trying to use it have been bad, and the
communication around the whole project has been worse.

------
mcbits
Have they decided not to support FreeBSD, or it's just extremely low priority?
I could swear I remember that being listed as a supported platform early on in
the project.

Edit: Ahh, okay, "Support the community extending CoreCLR in various ways
(e.g. FreeBSD support)"
[https://github.com/dotnet/coreclr/blob/master/Documentation/...](https://github.com/dotnet/coreclr/blob/master/Documentation/project-
docs/project-priorities.md)

~~~
wolfspider
Funny you should ask..I started this journey right here on HN. Still yet again
haven't had time to get back into it but I will take your comment as a
suggestion to try harder to find time for this. There is more information
about this here (if you are interested in the answer to "why" it hasn't made
it yet):
[https://github.com/dotnet/corefx/issues/10610](https://github.com/dotnet/corefx/issues/10610)

------
hbcondo714
> Continue to improve how you run .NET Core applications in Azure

This makes it sound like a sales pitch for Azure

~~~
tonyedgecombe
That's what MS developer tools are becoming.

~~~
fgonzag
And to be honest, it's kind of working. I'm still in the Kotlin/IDEA camp for
now, but at my shop we're a dual stack (.NET and Java for enterprise reasons)
and MS tools and Azure are getting seriously better. Once .NET core reaches
maturity and has 95%+ of .NET's standard libraries available, we might even
consider a full move to .NET as our automated processes and sysadmins are more
experienced with linux.

------
garganzol
2 years are passed and .NET Core lost its window of opportunities. The next
step? A dumpster can IMHO.

