[Music]
Welcome back to FSharp Conf,
and we have the last session of the conference.
It's been a great day.
And I'm surprised everything
worked smoothly so far.
- Yeah.
- So, we have a few members of the FSharp,
FSharp Team here in Microsoft
starting with Phillip,
he's the guy with the awesome hat.
- We'll have to cut -- There we go.
- Doesn't quite fit in our pictures.
- Hey.
- So, what -- what do you do?
- I'm the PM for FSharp.
- What does PM mean?
- Don't ask a PM what they do.
- [Laughter]
- I'm asking for what
does PM acronym means.
Pre-teen Meta.
- It's a program manager.
I don't manage programs, and I don't manage people.
- No, I think there's no way
to manage programs, they just run.
Right?
- Yeah, some of them.
- Will?
- Yep, so, I'm on the FSharp Team.
And lately, I've been dealing with the
tooling for Visual Studio in FSharp.
- And our surprise guest is...
- I'm John.
I also deal with FSharp Tooling and basically pick up
the slack whatever Will doesn't want to deal with.
Or Kevin Roots doesn't want to deal with.
And, so, that's my job.
- Glad to have you here.
- Mm-hmm.
- And, Kevin Ransom, would be with us, but at last
he's on vacation hanging out with his family.
And he said, oh, I really don't want
to hang out with these losers right now.
Just kidding.
He actually -- - He fixes all of our bugs.
- He does.
And he regrets that he couldn't be here,
he really loves Tomas and so, yeah.
- [Laughter] - A little too much, I guess,
you know, it's unfortunate - Yeah.
So, he loves me so much he has to run away
when I'm here so that he doesn't get distracted.
- Yeah.
- Cool.
- So, let's -- let's dive in.
We've got one question here on Slack,
asking what's the status of FSI on NetCore.
- Oh, fairly close.
Basically, just kind of all the pieces
are in place except for a MSN task that's sort of --
well, we kind of have working
but not like good enough to ship
that sort of knows where to go to find
references, kind of cross platforms,
so that any assumptions about
where an assembly might live
are not, you know, invalidated very in an ugly way.
- Yeah, all the design problems
for how we'll work it under
Core is, of course,
all implementation details to RNL.
- Yeah.
All right.
- Basically.
- It's all done except that
someone has to write some code.
- Right.
- Sounds good, sounds good.
- On the sort of similar node,
what's the status on the FSharp
type providers on Dot Net Core.
- We're done.
The mechanism for it totally works.
It's just a matter
of some libraries out there
basically absorbing the changes
in the type of infrastructure
which we're also taking part in.
There's actually a Beta where Don and some
members of the community worked really hard.
Beta of FSharp Core, FSharp.data,
I think it's 3.0-Data is the name of it.
And that one works totally across platform.
And so, some people have been
testing it out, they like it a lot.
So, we're kind of declaring victory there.
It's just a matter of the Eco-system
kind of slowly and steadily catching up.
It's -- I mean, it's going to take
a little bit of time,
but like the pieces are all there,
I think this totally works.
So, we're really excited about that.
- Well, if FSharp data can work,
then any other type provider can work.
- Yeah, that's a big one.
- Well, we'll have to wait for all the --
all the cool type providers from Pezzy Thing.
- Oh, geez.
- [Laughter]
- That all needs to be imported
to Dot Net Standard.
- Yeah.
- Yeah.
- So, we can get our nice --
- Does that mean we can play Battleships on tri-levels.
- Yeah, Battleships is the V-machine type of veter,
I think, obviously, the down side cal provider.
- Yeah.
That's my favorite, yeah.
- Cal provider.
- Yeah.
- We've got -- we've got some
more questions from the screen.
What's the process for deciding for what's
in the next version for FSharp?
- Oh.
Well, that's kind of --
it's an interesting question.
So, I mean, the process is we basically
is we have an open-source repository
for FSharp language suggestions.
Then, we have a repository for RFC's,
where, if the language suggestion is approved,
then, an RFC gets written.
And, once that's in a pretty good place,
we have a pull request
that's made on our
implementation repository.
And sometimes, like, the poll
request gets done first,
and then, the RFC is done,
it's a very collaborative process.
And as a feature, sort of nears completion,
we sort of hold onto it, and you know,
keep it up to date as change happens in a repository
and then, once we get to a place where we say, okay,
we have maybe three or four
language features where we feel --
we feel like they solve
some good problems.
They make a lot of sense together.
We bundle them up, package it up,
and then, we're in there.
So, we haven't done that over the past year or so
and we're actually looking to do that
for sometime later this year
we want to have some things
like anonymous records
and a few other features
that are basically complete.
And some awesome stuff from
the community that just came in.
It's just a matter of putting it
all together, testing it,
making sure that everything plays really well,
nicely together and then, that's kind of how we go
and moving forward the way we think about it
is FSharp evolves somewhat slowly
but gradually and steadily
so that new features come in.
It's an involvement with the community,
and when features are in a good steady stable place,
they get put into a new language version,
we rev that, and so on.
And so, we want the FSharp language to rev,
kind of a bit more slowly, a bit more steadily,
so that there isn't just this massive
set of features that goes in,
and, you know, hopefully,
everything works perfectly.
We want to have everything very well
tested, very reliable,
so that you can not only excited
about a new feature, but --
but basically, upgrade your code base
and not really have any issues.
- Actually use the feature.
- Yes, exactly.
- And hopefully, have everything
plugs through the tooling so
if there's any issues we can have that all ironed out
so it works nice and all the tooling.
- Yeah.
- So, you mentioned --
you mentioned the anonymous records, right?
- Mm-hmm.
- Do you remember any of this sort of other things
that will more likely
appear soon in the future?
- There's Match Bank keywords,
so that, you know, you let them result
equals something maybe inside an A-sync
but it wasn't optional.
And then, they get a match on the result
and that sort of stuff where you can condense
that down into a little match expression.
That's implemented by one
of the community members,
it's just that being a matter of coupled in
with a few other things and it's good to go.
Better warnings on matching enums in general
has also been done by the community
and that's in a fairly
decent state as well.
We're kind of at the point now,
where now we have type providers on,
we're going to get
FSharp interactive done.
Once that's sort of complete, we're going to think,
okay, there's going to be a new FSharp language,
sort of like the next major milestone.
And then, so, features like the Dot or whatever
we're thinking is going to be bundled in.
I guess once we have FFSI and type providers,
the next obvious step is to take over the world, right?
- Yes, exactly.
- Yeah, or use Fable
and put it out on the browser
or something like that.
- Yeah.
- The world.
- Right.
Sorry, yes, I guess that's the same thing isn't it.
- [Laughter]
- We've got a question here,
any plans in producing preview
versions of FSharp .5???
with approved and already done features?
- Possibly.
We really haven't thought about that
at this point, because it's kind of --
it's kind of hard to put
something in the compiler,
and then, like, you can't really
take it out at that point.
- Yeah, yeah, yeah.
- There may be just because we shipped
fairly frequently with Visual Studio previews
and with Dot Net Core
previews combined
just kind of making
everything to fit in there
so we don't like essentially
accidentally leak
a preview feature
into a release train
and then, all of a sudden, now, it's like a new feature
without a rev FSharp language version.
Like, where we definitely want to avoid
that sort of weird situation.
So, I think if we can do it, we will do it.
We just really haven't thought about it,
because our main focus has just been
finishing up the Dot Net Core bring up.
- Yeah.
- And we have the --
the V-6 that provides like, you know,
that you can get that could potentially
have new features in there right.
We could do that but we're probably
not going to ship it as part of a studio preview
just because that tends to be more like this
is definitely happening
versus experiments or whatever.
- Yeah.
- So, if people want to play
with some of these new features,
what should they do?
- Well, you could actually build
a version of the compiler
that has that basically the fourth
that has that poll request and you can try it out.
It's a pretty straight forward process.
There's basically, I think, all you need now
is MS Build on your machine
and then, all the other dependencies
will come down for you.
So, it's not too crazy to get started with that
if you want to try it out.
- So, we talk a bit about the language, now let's --
let's talk about the tooling.
So, what's -- what's coming --
coming up new in the -- in the FSharp
Tooling world?
- Okay.
So, the next release is going to have
much more kind of mail file
ordering for the new project system.
So, there's a couple bugs we had to resolve
and make sure that it's all good to go.
So, that's there, that's complete.
The next thing after that is going
to be focusing on performance.
Because right now, that is probably one of the --
one of the biggest things that we really need to tackle
and how that stuff is actually going
to work with the new project system.
Because there's still a little bit of work
there that we need to fix
in order to improve performance there.
We can also actually look at the compiler
directly to see what may be going on
and also do analysis
on the tooling side when --
when like doing things
in Visual Studio like
if there's weird things
going on in there,
that's like hogging down V-S.
We can profile that and that's what
we're going to be focusing on.
Because, one of the biggest
issues that we have.
So, hopefully, like, further down the road
maybe in the next like six months,
we should have like, we have, we should have some
really good solid progress on that.
- Yeah.
And there's actually been
quite a bit of perf work going on.
Don kind of carved out a large part
of his time to sort of say,
hey, we're going to take
a really good look at some of the stuff
that we've kind of had
for a long time in the compiler
that we're not very efficient
in cleaning that up
and then, in addition, we had a lot
of strong community involvement
particularly from Avi Avni
from the FSharp community.
He's just been sending tons
of poll requests and then we've been working with him,
you know, kind of pointing out,
hey, you can change this, that sort of stuff and like,
he's super excited
about this stuff.
So, a few of his changes are actually going to be in
the next version of Visual Studio.
- Yeah.
- 15.7, there are a few more that are not making it
because they were just kind
of fairly recently merged.
- Yeah.
- But those will be in sort of the next, next version.
And then, some of the stuff Will's
already been getting to.
- Yeah.
And so, also later on, we may have automatic brace
completion probably in the future.
- Yeah.
- Too.
- Including curly break.
- Yeah, yeah, we've got all of --
- All the basics.
- Anything you have.
- Okay, it's going to be --
it's going to be just like CSharp.
- You know, the array brackets, so, it'll just be a --
- So, that would just be completion journal,
so quotes, a bunch of different --
- Yeah.
- Things, right?
- Except for single code.
- Right.
- That's the only exception.
- All right, because they don't
necessarily mean a quote, right?
- Yeah.
- Yes.
- So, you can say X and X primes,
so, which one, yeah.
- That's the fun bit of tooling.
There's just infinite education.
- Including the FSharp quotations
with ankle bracelets at etet?
- Yeah.
- Yes.
- I'm looking forward to that.
- Yes.
- That will make quotations a lot more fun.
- The typed and un-typed variant
depending on which you prefer.
- Why would you always go to un-type
go to end a quotation?
What's that mean?
Just go for it.
- It's just like out there.
- Yeah.
- Cool, I see -- I see we've got one question here.
Can I write Dot Net
Standard Libraries
with FSharp?
Column dash and parenthesis.
- Who puts a -- yeah, who puts
a nose on their smiley faces anymore?
- German by the name
of Emilangred maybe.
But, yes, yes -- - But he did open the parenthesis, so,
I think this doesn't compile.
But if anyone wants to answer, go for it.
- Yes, you can.
You can write FSharp Dot Net
Standard Libraries.
- Yeah, anything that can be targeted by CSharp
in terms of a platform, we've targeted by FSharp.
- And Dot Net Standard means it runs everywhere.
- Yeah.
- Everywhere the Dot Standard is implemented.
- Yeah, everywhere is a lot of --
- So, what does everywhere mean in this context?
- Specifically everywhere you care about,
Dot Net Core, yes.
- Dot, so, it depends on the version
of Dot Net Standard implemented,
but let's say, Dot Net Standard 1.3,
that would mean any version of the Dot
Net framework that's 4.6 or higher, sorry, yeah, 4.6,
well, you know, it might correct me and then,
of course, you can run it on Mono or Dot Net Core, so.
- So, everywhere.
Does it promote Silver-light?
- There is a version that runs
on a version of Silver-light, yes.
- Okay, well, maybe --
- It's possible.
- It's possible.
- Yeah.
- Can you co-pilot it to Fable?
- Yes.
- Yes, of course.
- So, everybody leaves on everywhere even on My Fuse.
Let's see, do I have any more
questions coming from here?
I'll have to check in a second and then, we've got
one more question here, as a CSharp Library developer,
what should I know to make it great
for FSharp double efforts to?
- I think that's a great question.
- There's kind of a I think the two major things.
Number one, do not expose your entire hierarchies,
I don't think most CSharp helpers even like that so,
just don't do that that period.
Do not -- do not basically make
the consumer in this case,
an FSharp consumer have to deal
with immutable state.
Right?
If you can keep that all wrapped up nice
so you can have nice little interfaces
that you use to communicate
across assembly boundaries,
then, I think most FSharp developers
are going to be happy.
- Sounds good.
We've got one question here,
although, this might not quite be
for the FSharp Team here to answer.
What are plans on fontimous integration
into FSharp Compiler Services,
that's probably more of an
open-source doublement effort
than done something -- -
It is an over-source development effort
that we're also sort of stopping
until there are various bugs
and phantomous that get worked out because when you --
when you run it against the
FSharp Compiler source base it,
it actually deletes some stuff
and basically causes some bugs
and makes it so the compiler
won't be able to compile itself.
And so, it's kind of our main test bed.
- We should also say what is Phantamous.
- Phantamous is an FSharp formatter.
- Yeah.
- A source code formatter.
And it's -- it's pretty great actually.
I --
I recommend checking it out
and trying it on your own code base,
but it does have some issues
on the FSharp compiler code base
and that's kind of
our main test case.
You know, once that gets
resolved, then, it's --
it's like a much more realistic
thing in terms of computer.
- Yeah, then -- then you know.
- Yeah, we want it to work for 100 percent
FSharp Code before
we turn it on for everybody.
- We don't want to be deleting people's source code.
- Unless it's bad, right?
- Right, yeah, we'll delete
all the untyped end quote quotations,
we'll leave everything else.
- And is it going to delete all your
point freestyle and replace it with --
with point full style.
- Only if you use triple bagpipes.
- Triple bagpipes.
Oh, yeah, well -- is there like a Bit Coin integration
where if you triple --
triple back check it, it will
only comply when you pay in Bit Coins.
- Yeah, we do Bit Coin minor the compiler level
if you do do triple back check.
- Sounds like you -- - That was my understanding of it.
- You've got a good plan.
- A little F check.
- What is a F check again?
- It's a triple back check.
- All right, we've got some more
quick serious stuff here.
Please do more blog postings
on how to use FSharp to process excess DNX in our file.
- All right, do that Phil.
- So, that's more like a data processor,
like, so, it's kind of more like a --
I guess I'm interpreting that
as we should blog about --
well, first of all, we should blog about using
FSharp about interesting stuff more.
- Yeah.
- That's something that's kind of always on my back log
and I have various drafts
that are still not completed.
But, in the -- in the sort of using FSharp for data
processing, I think, is certainly a valuable blog post.
I think it would be --
- Yeah.
And I think the -- the latest
preview of the data library
also comes with
the excess D-type provider.
- Oh, wow.
- I -- I believe so.
- I don't know.
- It's -- it's been sparing my in-box
with Git Hub notifications
for the last few weeks.
So, there was definitely some -- some talk about --
about the excess D-type provider again.
Which might make for a fun blog post.
But, it doesn't necessarily
have to come from you.
So, if you're watching us and if think of anything
about excess DNX, maybe you should write the blog post.
- And we're also happy to kind of
take a really high quality blog post
and basically put it on the Dot
Net blog as like a re-post.
And then, we just sort of a have
a little thing at the top that says,
hey, you know, this was written by,
you know, your name,
here's, you know, a link to the original post,
here's a link to the author's Twitter,
that sort of stuff and then,
just basically go from there
and that can increase visibility a whole lot.
And we've done that for the past.
- Now that we're chatting about sort
of documentation and tutorials,
what's the FSharp documentation
status on Microsoft
and is this something that people
can contribute to you as well?
- Yes.
So, there's -- it's kind of a confusing split right now
that we're working through
but it's taking a long time.
There's -- there's the notion of reference
documentation and conceptional documentation.
And so reference documentation
is basically the FSharp Core Library reference.
Just, you know, an enumeration of literally
every single function and type
and setting in FSharp Core Library.
A little sample of what it's all about.
And, you know, some remarks explaining,
you know, in a way that might use it,
and you might not use it
to a certain circumstances.
And then, there's conceptional docs which are,
you know, how to get started with VS,
VS-Code, VS for Mac,
Donner Course C
Live, Tour of FSharp,
and what we call the FSharp Language
Reference, which is basically
kind of an exhaustive
every single feature
of the language you know.
First of all, what's it syntax
representation generally.
What are some remarks about like what --
what it's all about.
Code samples, that sort of stuff.
And it's a fairly large docs set
and the latter part, the conceptional docs type,
entirely open source on Git Hub.
They're on the GitHub.com/.net/docs repository.
Everything that's on Microsoft.com/.net/FSharp
and that's all open source.
There's even like a little edit button,
if you click it,
it'll take you to the article in Git Hub
and then, you can modify it from there.
The reference documentation, we're in
the process of migrating over to Dot Net Microsoft.com.
However, there are some issues
in the code generator that basically reads an assembly
and then tries to output what it all is
and there's some stuff that
still needs to be finished
basically if we were to do that today,
a few things in the Core Library
would look like total garbage
and, you know, we can't do that.
[Laughter]
So, that one, it is also
still backed by Git Hub,
but it is considered
a frozen repository,
so, you know, unless, you know, there's something
that's just plainly misleading, then,
we basically say, hey, you know,
we'll kind of hold off,
you know, these changes
may not necessarily make it
when we report stuff over.
And so, you know, we don't want you
to do a bunch of work here
and then, effectively lose
those changes potentially.
So, that's kind of
the current status.
But, yeah, basically open source, especially for
the stuff that actively describes a language feature
and why you might want to use it and why you might not
want to use it under certain circumstances.
The place for that is
100 percent open source.
We really welcome contributions there.
- So, are there something that people
sort of contributed recently,
or some areas where
you think there's like,
that's that's where people should focus
if they want to help with the docs?
- I mean, we've been getting various fixes
like, I mean, numerous people,
they basically look up a feature
and they notice the code sample
it's either not ideal
or maybe something is
a little out of date.
Maybe not the best way to represent it.
Had multiple changes over the past couple months
just coming in to fix that stuff.
I'm also working on kind of
an FSharp Style Guide Section
that some of the community members
are really invested in right now
and I think they have something
like 160 feedback comments already.
Just line by line literally going everything
that's being written down
and saying, you know, yes, no,
hey, maybe change it to this, like it's --
it's actually pretty active
with contributions going on it.
- All right.
So, I think it's probably
time for us to wrap up.
Do you have any sort of last -- last words,
last comments on what --
- What are your last words?
- Do you have any last words?
- Do you have any last words
on what you're working on?
What are -- what are you excited about?
What should people watch?
Let's start with that.
- I'm excited for reving
a new version of language.
I'm excited for excited for all the perf work
that we're going to be doing.
Just tons and tons of performance work.
I'm really excited for that
to be the main focus.
Because, I think we have a good set
of features, we just need to make it really fast.
And that's kind of the main stuff also.
I'm really excited to have an FSharp Style
Guide in there because a lot of new beginners
new to the language
have talked to me specifically
and said, "Hey, I don't know if the code that
I'm writing is the right way to do it."
I'm like, well, that's kind of
what the Style Guide is for, so.
- Yeah.
So, basically, same thing is,
Phillip, is I'm really excited
is start actually doing
the performance part myself,
and figure out like what,
what, what's going on.
And let that be my main
priority for awhile.
And I am excited about the Style Guide too.
That's something that we can
definitely been in need for awhile.
So, those -- those are
the two big things for me.
- Yeah.
I'm the only one that's excited
about performance.
No, I'm kidding.
But the just NSF and temporaries
coming on for a DynaCore,
I'm really excited for what that's
going to do for the Eco-system
as that gets on, all of a sudden,
type of virus are available like everywhere.
And, you know, Foon could
be using type of virus.
- Yeah.
- For all sorts of reasons.
That's really exciting.
And also, we've got just a bunch of
just small but fun fixes in terms
of like getting people
templates for ASPI.net
and the web and a bunch of just like filling out
the experience for tooling for FSharp.
- Sounds great.
So, thanks very much for joining us.
And it's been a great day.
I think I definitely need to --
need to wrap up now and have a bit of a break
because it's been a long day as well.
I do have to say, we did have --
we did have some amazing feedback on Twitter.
So, people in Switzerland have been
live-streaming FSharp Conf and now it's almost 3 AM.
- Oh, wow.
- Holy cow.
- And they're still live-streaming.
- I am impressed.
- That is insane.
You people are awesome.
And that's not like just, you know,
the American awesome which means,
like, yeah, it's like the actual awesome.
- That's like the European also.
- Yeah, the European awesome.
- Oh, wow, wow, that's wild.
- Yeah, yeah, cool.
- So, thanks for watching, and keep in mind the talks
will be posted on Channel 9, so, if you miss something.
Maybe because you have to actually
do some work during the day.
Such a shame, you can -- you can find
all the recordings, pretty soon on Channel 9,
we'll post the links
to FSharp Conf as well.
And you can join the FSharp Foundation
and continue the chats
that we started here
on the FSharp
Foundation Slide.
Thank you very much, and see you next time.
- Bye-bye.
- See you.
[Music]
