I've never much liked the whole "dnvm" and "dnu" and "dnx" command line stuff in the new ASP.NET 5 beta bits. There's reasons for each to exist and they were and they have been important steps, both organizationally and as aids to the learning process.

My thinking has always been that when a new person sits down to learn node, python, ruby, golang, whatever, for the most part their experience is something like this. It should be just as easy - or easier - to use .NET.

This is just a psuedocode. Don't sweat it too much.

apt-get install mylang #where mylang is some language/runtime

#write or generate a foo.fb hello world program

mylang foo #compiles and runs foo

I think folks using and learning .NET should have the same experience as with Go or Ruby.

Easy To Get - Getting .NET should be super easy on every platform. We are starting to do this with http://get.asp.net and we'll have the same for .NET Core alone, I'm sure.

Easy Hello World - It should be easy to create a basic app and build from there. You can "dotnet new" and get hello world. Perhaps more someday?

Easy Compile and Run Just "dotnet run" and it compiles AND executes

Real .NET Fast, scalable, native speed when possible, reliable



I've been exploring the (very early but promising) work at https://github.com/dotnet/cli that will ship next year sometime.

IMPORTANT NOTE: This toolchain is [today] independent from the DNX-based .NET Core + ASP.NET 5 RC bits. If you are looking for .NET Core + ASP.NET 5 RC bits, you can find instructions on the http://get.asp.net/.

Once I installed the "dotnet" cli, I can do this:

>dotnet new

>dotnet restore

>dotnet run

Imagine with me, when you combine this with the free Visual Studio Code editor which runs on Mac, Windows, and Linux, you've got a pretty interesting story. Open Source .NET that runs everywhere, easily.

Here is a longer command line prompt that includes me just typing "dotnet" at the top to get a sense of what's available.

C:\Users\Scott\Desktop\fabulous>dotnet

.NET Command Line Interface

Usage: dotnet [common-options] [command] [arguments]



Arguments:

[command] The command to execute

[arguments] Arguments to pass to the command



Common Options (passed before the command):

-v|--verbose Enable verbose output



Common Commands:

new Initialize a basic .NET project

restore Restore dependencies specified in the .NET project

compile Compiles a .NET project

publish Publishes a .NET project for deployment (including the runtime)

run Compiles and immediately executes a .NET project

repl Launch an interactive session (read, eval, print, loop)

pack Creates a NuGet package



C:\Users\Scott\Desktop\fabulous>dotnet new

Created new project in C:\Users\Scott\Desktop\fabulous.



C:\Users\Scott\Desktop\fabulous>dotnet restore

Microsoft .NET Development Utility CoreClr-x64-1.0.0-rc1-16231



CACHE https://www.myget.org/F/dotnet-core/api/v3/index.json

CACHE https://api.nuget.org/v3/index.json

Restoring packages for C:\Users\Scott\Desktop\fabulous\project.json

Writing lock file C:\Users\Scott\Desktop\fabulous\project.lock.json

Restore complete, 947ms elapsed



NuGet Config files used:

C:\Users\Scott\AppData\Roaming\NuGet

uget.config

C:\Users\Scott\Desktop

uget.config

C:\Users\Scott\Desktop\fabulous

uget.config



Feeds used:

https://www.myget.org/F/dotnet-core/api/v3/flatcontainer/

https://api.nuget.org/v3-flatcontainer/



C:\Users\Scott\Desktop\fabulous>dotnet run

Hello World!

Note that I ran dotnet restore once before on another projects so that output was not very noisy this time.

Native Compilation of .NET applications

This is cool, but things get REALLY compelling when we consider native compilation. That literally means our EXE becomes a native executable on a platform that doesn't require any external dependencies. No .NET. It just runs and it runs fast.

It's early days, and right now per the repro it's just hello world and a few samples but essentially when you do "dotnet compile" you get this, right, but it requires the .NET Core Runtime and all the supporting libraries. It JITs when it runs like the .NET you know and love.

But if you "dotnet compile --native" you run it through the .NET Native chain and a larger EXE pops out. But that EXE is singular and native and just runs.

Again, early days, but hugely exciting. Here's the high-level engineering plan on GitHub that you can explore.

Related Projects

There are many .NET related projects on GitHub.

Sponsor: Big thanks to Redgate for sponsoring the feed this week! Have you got SQL fingers? Try SQL Prompt and you’ll be able to write, refactor, and reformat SQL effortlessly in SSMS and Visual Studio. Find out more with a 28 day free trial!