
ASP.NET 5 is dead – Introducing ASP.NET Core 1.0 and .NET Core 1.0 - highmastdon
http://www.hanselman.com/blog/ASPNET5IsDeadIntroducingASPNETCore10AndNETCore10.aspx
======
zargath
I know naming is one of the hardest things in Computer Science, but ".net"
always stroke me as the worst name ever. Just like C, C#, Go and Node. You
wonder if they sat down and said "Lets take over the internet, what word do
people use the most?". I remember when I started using .net when it was in
beta 15y ago, searches on "c#" or ".net" simply wielded no results, because of
naming and search engine limitations.

When .net launched, it introduced vb.net, that gave Visual Basic support. Not
a smooth transition, but it gave some developers a bridge to stand on. I
wonder why Microsoft didn't just skip the .Net name to signal a new change in
both technology and philosophy instead of getting heads blown up by old
developers not understanding the switch.

~~~
50CNT
There's a lot more of those, isn't there. I still remember the time I got on
HN and couldn't tell the tech announcements from the news articles. Can't
remember any exact titles, but stuff along the lines of "Coffee.net now ships
Espresso". Is that a site that sells elixir of life or some kind of javascript
and .NET amalgamation shipping a new library?

Go, Python, Lisp, C, C#, Java, all these words getting double booked to make
them memorable. If I want to find a place to fix my lisp, do I go on stack-
overflow or to a speech therapist? Book on Go patterns? "Java island book"?

But luckily nowadays we can abuse word connections to get google to spit out
the right things. "Python generators" may refer to a machine to generate
snakes, but short of living in an xkcd comic, it'll probably return the right
results. It just gets a little muddled when developers find just the right
collocation to name their pet python [project?]. But then we just heap on more
specifiers. Unless you decide to call your library "THE" in a fit of genius.

Like Tabasco in your eyes, it just adds spice to your search experience,
doesn't it.

~~~
matt4077
... off to start the THE project...

~~~
50CNT
Shoot for something absolutely essential, destined to be widely used, and if
you feel that sadistic streak shining through, start using a word frequency
list[0] to name project parts. "of", "and", "in", "to", "in", "I" and "that"
will make for marvellous library names, especially if you find a way to hack
around the reserved words of your language of choice. Java and C seem like
appropriate choices of language, assuming key parts are actually written in
Whitespace and/or Brainf*ck. Make it open source, and nest the layers of WTF
so it seems like something you could dive into easily.

Maybe if you make all the bad development choices deliberately, you'll
actually end up with a beautiful project, because the reverse seems to happen
quite frequently.

[0][https://en.wiktionary.org/wiki/Wiktionary:Frequency_lists](https://en.wiktionary.org/wiki/Wiktionary:Frequency_lists)

------
andyjohnson0
I've been developing on the .net platform for >10 years. Increasingly I get
the feeling that I no longer fully understand its extent, how it all fits
together, and what is and is not "legacy". Can anyone recommend a
comprehensive and up-to-date survey on the platform for someone in my
position?

~~~
NicoJuicy
This is what i think.

.Net ( normal) is Windows only, there's mono which is based on .Net itselve
and supports Mac. .Net Core is a extensions on the origin of Mono. Making .Net
available on every platform. But Microsoft underestimated the effort it would
take. So they are going the .Net Core way for better cross platform support
(i'm not saying Mono is bad, fyi!)

.Net core is a fork of .Net framework, with support for all platforms (
Windows, Linux and Mac). It tries to support as many things as possible, the
hard part is graphics. Which causes problems for WPF and Image processing.

Asp.Net MVC 4 - 5 - ... is based on .Net frameworks.

Asp.Net 5 is a refactoring of asp.net MVC which supports .Net core and .Net.
Which causes difficulty for cross platform support ( some dll's are in a
different location using the .Net Core). Also, .Net Core doesn't support
SignalR and image processing ( as mentioned in
[https://github.com/imazen/Graphics-vNext](https://github.com/imazen/Graphics-
vNext) )

They are now renaming .Net Core to v. 1.0 because there will be some
differences between .Net core and .Net and it's more logical, because .Net and
.Net core is not the same. But they are looking into it to minimize the
differences.

Just to be sure, SignalR and Image Processing and graphics problem are going
to be solved. Just not yet.

Asp.Net Core runs on both .Net framework and .Net core.

.Net Core will be used for cross platform development, while .Net framework
will be used for Windows Only development ( probably WPF, because it isn't
released as opensource yet)

Nothing is legacy, Windows has always supported older versions of the .Net
framework. I can even run .Net 1.0 on Windows Server 2008... That means a lot.

The difficulty for .Net developers is, that .Net core will be using a lot of
opensource tools, that they don't have any experience with.

You can stick to your old pattern if you want, but i'd advice to learn the new
tools, that other frameworks are using ( grunt, gulp, ...) . You would come in
contact with them outside of the .Net framework :-)

~~~
graycat
Thanks. I was guessing that, but thanks for the confirmation and details.

~~~
NicoJuicy
You're welcome :)

------
merb
More confusion.

I hope you will soon have a streamlined way of developing .NET Core 1.0 /
ASP.NET CORE 5 or whatever.

Currently we have dnx/dnu and dotnet, I prefer dotnet but it is still really
really buggy and dnx/dnu is somewhat aweful to use. It's really hard to get
started / trying stuff out. Other starting languages were a little bit easier
to test, I remeber Go 0.7 it also had a tool to replace 0.7 stuff with 1.0
stuff, however It was a whole new ecosystem so maybe it's harder to actually
build something on top of something already there.

~~~
mrweasel
It has become really confusing to get started with .NET. There's a ton of
stuff just from Microsoft, and it's kinda hard to understand how everything
fits together.

I recently did a project where we wanted to a small built in webserver.
Understanding how all the OWIN stuff fits together and knowing which libraries
to use is hard than doing the actual coding. For a compiled language it's
confusing that your code will compile, but not work, because you forgot a
"using".

Go is younger and therefore doesn't have the baggage of .NET or Java, but it's
a good example of how simple a "development environment" can be. It's not
alone, Python, Lua and others are also much much easier to get started with,
without being bombarded by a ton of acronyms and surrounding infrastructure
libraries.

~~~
cmdkeen
"A small built in webserver" is exactly what ASP Core now gives you. ASP.NET
was never previously about providing that, and it wasn't a thing until fairly
recently.

Now with Kestrel you only need a handful of lines of code to spin up a web
server.

The whole point of Core is that MS have rewritten .Net and ASP to learn the
lessons of more modern languages. ASP.NET 4.6 is standing on 19 years of cruft
which is why it has so many weird and complicated parts.

~~~
otis_inf
> The whole point of Core is that MS have rewritten .Net and ASP to learn the
> lessons of more modern languages. ASP.NET 4.6 is standing on 19 years of
> cruft which is why it has so many weird and complicated parts.

MS hasn't rewritten .NET, most code is simply ported from .NET full. ASP.NET
has been rewritten, but only a part of it (the rest is simply not implemented
(yet)). '19' years of cruft? .NET 1.0 was released in 2002, not sure where
your 19 years come from. Besides, it's better to use a framework that actually
works and does whatever you throw at it, than some hip new thing that can only
do a few tricks today and perhaps learns a few more tomorrow. You know,
clients and all, they want to use the stuff you write and not have to stare at
things that break down / crash.

~~~
cmdkeen
ASP (i.e. ASP Classic) is 90s though, and plenty of its legacy lives on for
instance in the ASP.NET Request object.

ASP Core isn't going to be able to do "a few tricks" when it's released, it's
going to be production ready for a wide range of standard tasks with
significant benefits for newer architectures like micro services. "Clients and
all" might like having scalability options that don't involve waiting 20
minutes for an AWS Windows VM to spin up for instance...

------
hudo
Looking at the post RTM plan, and I really hope they will de-prioritize VB
work and push F# more! It has so big potential to attract wider community and
bring back some good OSS devs. Except few big companies that needs to maintain
legacy apps, nobody really cares about VB any more, specially in some brand
new dev stack like asp.net core. Waste of time and resources IMHO. I was a VB
dev, and it really made sense 20y ago. Now, I haven't heard somebody is using
VB (excluding some bank maybe - but they're mostly stuck in .net 2 or 3).

~~~
DanielBMarkham
Couple of really nice things about F#:

\- It's multi-paradigm. If you just gotta have classes? Go make some. But if
you want to learn and take your game to the next level, you'll soon ditch a
lot of them. F# means you can move from OO to (mostly) pure FP without having
to change languages or stacks.

\- You can plug in stuff made in all the other .NET languages. There's a ton
of stuff out there that you can just pick up and use.

I like F# because the more I use it, the better I get. I know I don't want
classes, for loops, mutable state, and the rest -- but sometimes I just can't
see how to get around them. So I throw them in there, get the code to work.
Then I go back and figure out where I went wrong. Those "going back" moments
are like miniature programming lessons tailored just for the things I don't
understand well. Very cool.

~~~
graycat
> But if you want to learn and take your game to the next level, you'll soon
> ditch a lot of them.

"Next level"? Sorry, I don't believe it. All I see is more _programming style_
, and that is no more significant for something better than some new Paris
designer dress style.

 _Functional programming_ style? Not interested. Showing that P = NP? Sure,
interested!

~~~
lsadam0
I'm not seeing your point. Your posts I have read thus far are arguing for a
specific programming style....but you dismiss all other programming styles.
Your style is just another 'paris designer dress'.

Objectively, certain styles have distinct advantages over others. Your
argument comes across as "Broadband? Why would I need broadband? I have a
perfectly fine dial-up modem!".

I'm trying to say this as nice as possible: You come across as a person who is
against learning any new concepts. As if you learned one thing many years ago
and refuse to change.

~~~
graycat
I learn new stuff right along. Just now I'm trying to get my startup live so
am cutting back on learning new stuff, but I have several lifetimes of new
stuff I'm eager to learn.

I've learned lots of new stuff in computing and in programming languages. But,
by now, in programming languages, mostly I give up -- structured programming,
object oriented programming, logic programming, rule based programming,
functional programming, programming based on actors, threaded, stack based
programming, frame based programming, strongly typed programming, programming
based on communicating sequential processes, literate programming -- because
the tools are, net, not better.

For some progress, it would be good to be able to have some proofs of
correctness. I looked at that field, and it's hopeless: First problem, the
proofs are too long and hard to do, e.g., have some astounding collection of
induction arguments. Second, with programming language _side effects_ , etc.,
have to assume away a lot of possibilities for errors. Third, a proof needs
some hypotheses and conclusions, that is, _givens_ and results, and for
realistic software those two are too difficult to have in precise terms. E.g.,
for realistic software, it's just too tough to describe in principle, as
needed for a solid proof, all the possible inputs and what should be done for
all the cases. So, attention to proofs of correctness mostly went away.

Net, in my programming, for progress in having the software simple, efficient,
easy to understand, easy to write, debug, and change, my approach is just good
conceptual design, documentation, and use of the basic tools in VB .NET. I'm
no longer looking for such progress via programming language syntax,
semantics, constructs, or features.

------
swalsh
As a .NET developer turned rails developer, looking back at .NET core 5 (on
osx) I like what they're trying. I feel really at home because i love the
rails workflow, but i love C#. It's not quite ready for primetime yet (in my
opinion), but I could see myself going back in the future.

That said, I feel like my rails experience is helping me understand the new
.NET works a lot better than my previous .NET experience. So I think the name
change is appropriate. It's different enough.

~~~
Yuioup
I think that .NET Core takes a lot of inspiration from node.js as well.
Probably why it feels a bit different from Rails.

------
BillinghamJ
Sure this makes sense if you've read the explanation behind it, but this type
of change is bad for new users - very confusing.

~~~
SideburnsOfDoom
The intention seems to be that when the dust settles, it will be easier and
simpler for new users to get started. As others have mentioned, the "install
and start coding" experience has to compare well to ruby, python, node.js etc.
Like this: [https://dotnet.github.io/getting-
started/](https://dotnet.github.io/getting-started/)

~~~
AwesomeBean
Indeed - I think this is a welcome change. Might make it confusing for a year
- but makes way more sense for the next 14 years.

~~~
BillinghamJ
As though they're not going to do more name changing during that time :)

------
navd
Although I think it's great that Microsoft is moving to oss and cross platform
dev, I can't help but still believe that moving from the .net ecosystem to
others like go and ruby was the best move I could have made for my sanity and
overall developer happiness.

I love C# as a language, but the development story is still extremely
disappointing. I want Microsoft to stop trying to hold my hand -resulting in
cookie cutter applications- and give me the freedom that I experience writing
applications in a language like Go. If Microsoft wants a larger set of the
developer mind share they need to stop playing catchup (integrating bower and
gulp? Who really cares.) and start creating more great tooling I can run from
the command line.

