Fsharp: F# and Visual F# Tools announcement for June

[cartermp]

Hey folks,

Sorry for no announcement within the actual month of June. There still wasn't a lot of clarity on our end about what exactly would ship in each concrete asset (.NET Core, and VS tools) and when that would be. There's more clarity now. Here's a high level overview.

What's new?

Quite a few things are new. The major focus area for the team has been .NET Core 2.0.

Barring any unforeseen, super critical issues, F# will ship alongside C# on .NET Core 2.0 on day 1.
.NET Core 2.0 support is quite stable now. The bulk of the work was in moving F# in-band with the .NET Core SDK so that we would be built and tested directly alongside C# and VB. There were also some bugs fixed, and we do daily scenario validation with each new build of the SDK and CLI.

There are still remaining issues to work out - Type Providers, Code Quotations, and FSI support - but F# support is stable enough now to the point where these can be looked and delivered after the initial release of .NET Core 2.0 and .NET Standard 2.0.

We also are completing work to enable F# to be built from source on .NET Core. This works on macOS today, and is being validated on Linux distributions. When you download the .NET Core sources at release, you will be able to build them all from source, including F#.

We also worked with the community in establishing a plan for publishing FSharp.Core under the FSharp.Core NuGet package. You'll notice that the owners of this package are "F# Software Foundation, Microsoft". This is intentional. This is a first step in longer-tail efforts to work more with the community and make sure that both Microsoft and the FSSF/F# community are seen as delivering F#. We still haven't figured out what all of that means. But we want to avoid a world where Microsoft and the FSSF/F# community deliver different things to accomplish the same goals. We think .NET Core is a good place to kick that off.

Additionally, the VS 2017 Updates milestone has moved from 5% complete to 74% complete over the course of ~4 months. And this is with many, many more issues added to that milestone in that time frame. These are a mix of bugs, feature requests, and augmentations. The majority of this movement has come from the F# community. To those who made this happen, thank you. You're an incredible group of people.

Finally, VS 2017 Update 3 will feature the first bits enabling F# support for .NET Core in Visual Studio. There is one remaining work item for us to do in our language service. We are doing it this week. Once it's finished, we believe that it will be a good experience overall. In addition to .NET Core support, this will be using the new project system that the .NET IDE team is building. They have built out almost all of the support, and are dedicated to continuing work there to support F#. You can track issues related to this work here. We're very, very excited about this work. This project system is an upgrade to the F# project system in nearly every conceivable way: project load times, reliability, maintenance cost, and much more. Our long-term goal is to move F# entirely over to that project system so that we can finally be rid of the current F#-only project system. We don't have a timeline for this yet, but this is a top-of-mind item for us.

Here are some additional things accomplished:

• Numerous bug fixes in the F# compiler. Some perf improvements as well.
  
  
  
  • These will be shipped alongside VS 2017 Update 3.
  
  
• Removed the generation of PCLs from our build
  
  
  
  • PCL is now deprecated technology with .NET Standard 2.0 being adopted by Xamarin
  
  
  • The PCL templates will still exist in VS, but under a legacy folder
  
  
  • We will not perform updates to PCLs anymore aside from super critical bug fixes
  
  
• Made significant progress towards moving our build entirely off of project.json
  
  
  
  • Still some remaining work to do, but we're close
  
  
  • This work will allow us to free up resources on internal builds
  
  
  • We're on track to finish this soon
  
  
• Fixed bugs on .NET Core
• Fixed numerous internal bugs related to crashes, our build, and bugs
• Established a nightly release channel for Preview builds of VS
  
  
  
  • More on this later. There will be a blog post explaining this and how to onboard
  
  
• Fixed multiple bugs related to support on the new .NET project system
• Currently working with the good folks at Jet.com to pin down issues with project load performance, IntelliSense performance, and more
• Added F# support for the 1.x SDK shipping inside of VS 2017
• Inserted templates for .NET Core and .NET Standard projects, which will "light up" at release

What work is remaining?

As mentioned above, there is still remaining work. Here's a re-stated overview.

• F# Interactive support on .NET Core
• Type Provider support for the F# compiler in the .NET SDK (even for .NET Framework programming with new project file, see this issue for a workaround)
• Type Provider support for .NET Core and .NET Standard programming (see this issue for a workaround)
• Full Code Quotations on .NET Core
• Remaining work to move the F# build onto the .NET Core SDK
• Infrastructure work for VS tooling

If you wish to try out some preview bits and report issues, here's how:

1. Install VS 2017 preview with F# and .NET Core support if you're interested in using VS.
2. Install the CLI and SDK from this link: https://github.com/dotnet/cli/tree/release/2.0.0#installers-and-binaries

The second step is critically important, as there are numerous issues fixed in that branch.

And just to clarify, there is currently no affinity between .NET Core versions and VS Preview or VS 2017 versions. .NET Core 2.0 is currently entirely out of band with VS 2017. There are no current plans to make .NET Core ship in the same "package" as VS 2017. As .NET Core 2.0 updates (and F# support for it also updates), you can simply update .NET Core on your machine. There is no need to wait for a VS update to see bug fixes or improvements in this area.

Additionally, there are three major long-tail efforts that we've planned. We have not "costed" this work yet, as we're head's down for .NET Core 2.0 support, but these are top-of-mind things that we want to see accomplished.

1. Infrastructure improvements so that we can remove our internal copy of this repository for localization purposes. We'll move to a newer localization toolkit, and eventually build F# tooling in VS as a part of the same build that Roslyn does. This will free up a nontrivial amount of our time.
2. Moving F# entirely off of its own project system and onto the .NET Project System. Our current project system isn't very pretty. It's a bit of a hornet's nest when you want to make any changes, with small improvements in one area causing a catastrophic failure in others. It has performance issues that many people suffer from. And finally, it's awfully difficult code to comprehend. Being able to rid ourselves of this baggage to move to a modern project system owned by experts in this space is going to be a huge improvement for F#. We're very, very motivated to make this change.
3. All the remaining work in this issue. This unification of assets will allow us to make cross-platform work easier across all the different places F# exists in an editor. It will also allow us to work on infrastructure to the point where we could consider moving the F# compiler itself _out_ of this repository. This is something we'd like to see happen, but there is currently no good infrastructure or testing in place to enable this in a safe way. The linked issue tracks work needed to move F# in that direction.

So, how about some dates?

No dates at this time. Sorry! Things are very, very tight right now for F#, .NET, and VS 2017. You can try out preview builds to assess F# and .NET Core today. Much of you have been doing this already, including reporting critical bugs that have since been fixed. Thank you for this. As stated earlier, we do daily validation of scenarios, but the more eyes that can look at stuff, the better things will be. Thanks!

[buvinghausen]

Thanks for the clarifications @cartermp & @dsyme

I will implement the workaround to get the type provider working with the dotnet cli as an interim step to FSharp.Data being released on .netstandard2.0

Thanks for all the efforts they are very appreciated this is an exciting time for the platform and I cannot wait for F# to be a full blown first class citizen across the board.

[dsyme]

@buvinghausen Thanks for the encouragement Brian!

There will be a lot of work to do to keep improving out .NET Core/.NET SDK story and help bring community projects across to the SDK, the community would love to have your help where you can :)

[cartermp]

Closing old discussion.