Ionide and state of F# open source ecosystem
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Alternative Title |
| |
| Title of Series | ||
| Number of Parts | 133 | |
| Author | ||
| License | CC Attribution - NonCommercial - ShareAlike 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/48806 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
NDC London 20161 / 133
2
6
10
12
15
17
23
24
28
30
31
32
35
36
39
40
43
44
45
47
51
52
55
58
59
60
61
62
63
64
67
69
71
73
74
75
82
84
86
87
97
103
107
108
111
112
114
115
117
120
123
126
128
129
132
133
00:00
Open setOpen sourceSoftware developerProgramming paradigmMultiplicationFunctional programmingSoftwareCodeProgramming languageFormal grammarSelf-organizationClient (computing)Revision controlLocal GroupFunctional programmingSoftware developerPoint (geometry)Client (computing)Physical systemType theoryComputer networkOpen sourceCoefficient of determinationRevision controlECosMereologyProgramming languageExterior algebraInternetworkingVirtual machineProduct (business)Level (video gaming)SpacetimeSystem callProjective planeControl flow2 (number)Slide ruleSelf-organizationFunctional programmingDigital rights managementCausalitySoftware testingFeedbackFamilyGroup actionCommutatorMathematicsSinc functionFormal grammarComputer fileCodeSimilarity (geometry)Open setJSONXMLUMLComputer animation
05:49
Software developerLocal GroupOpen sourceStatisticsBuildingAlpha (investment)Graph (mathematics)Computer networkDirected setGraph (mathematics)Computer fileProjective planeFitness functionInclined planeRevision controlProgramming languageBinary fileFile formatNumbering schemeGroup actionType theoryInternet service providerProduct (business)RootRepository (publishing)Communications protocolData structureOpen sourcePhysical systemStatisticsClient (computing)Normal (geometry)Level (video gaming)Library (computing)Price indexParameter (computer programming)Computer networkResolvent formalismInformationCodeSoftware testingGoodness of fitLocal ringData storage deviceFreewareIndependence (probability theory)CASE <Informatik>VotingTwitterDivisorComputerReal numberInstallation artResultantFamilyLine (geometry)Direction (geometry)2 (number)Web 2.0Binary codePoint (geometry)Profil (magazine)Data miningComputer animation
11:32
Software developerRule of inferenceRevision controlInstallation artDirection (geometry)ResultantGroup actionComputer fileApplication service providerSoftware testingLevel (video gaming)Web 2.0Source code
12:45
Software developerMultiplication signCASE <Informatik>Exterior algebraProduct (business)Order (biology)Client (computing)Software testingHand fanProjective planeLength of staySinc functionComputer fileWeb 2.0Direction (geometry)Electronic mailing listApplication service providerType theorySource code
13:26
Client (computing)Revision controlSoftware developerPhysical systemSpacetime.NET FrameworkSoftware developerClient (computing)Software testingEnterprise architectureComputer networkNormal (geometry)Projective planeExterior algebraProblemorientierte ProgrammierspracheHoaxDigital rights managementAutomationSinc functionSpacetimeComputer configurationProduct (business)Numbering schemeEvent horizonMusical ensembleMyspaceMultiplicationProgramming languagePower (physics)Focus (optics)Physical systemFilm editingComputer animation
15:57
Software developerGroup actionMoment (mathematics)HoaxLine (geometry)Numbering schemeRevision controlAdditionComputer fileBuildingScripting languageParameter (computer programming)Normal (geometry)Sinc functionModal logicMultiplication signUltraviolet photoelectron spectroscopyClient (computing)Power (physics)Computer animationSource code
16:49
Software developerDefault (computer science)Function (mathematics)BuildingConvex hullSoftware testingExecution unitExecution unitMultiplication signTask (computing)CodeStack (abstract data type)MathematicsParallel portProblemorientierte ProgrammierspracheBuffer overflowHoaxComputer fileProjective planeGraph (mathematics)BuildingCASE <Informatik>Set (mathematics)Parameter (computer programming)Functional programmingDirectory serviceProgramming languageBootingReal numberWebsiteProduct (business)Right angleComputer animation
20:01
Text editorSuite (music)Computing platformError messageDisintegrationSoftware developerCodePhysical systemScripting languageIntegrated development environmentRight angleCommutatorText editorBlogProjective planeMultiplication signMoment (mathematics)MereologyWeb 2.0Template (C++)Graphical user interfaceHoaxSoftware developerLibrary (computing)Cartesian coordinate systemINTEGRALExtension (kinesiology)CASE <Informatik>Flow separationData structureType theoryProduct (business)Thermal conductivitySharewareAutomatic differentiationOpen sourceMachine visionPower (physics)Student's t-testVideo game consoleCodeVisualization (computer graphics)Normal (geometry)Point (geometry)Electric generatorSimilarity (geometry)Different (Kate Ryan album)Plug-in (computing)Error messageCuboidGoodness of fitComputer clusterAlpha (investment)Computer animation
25:36
Software developerLine (geometry)HoaxMoment (mathematics)Data structureOperating systemMereologyVariable (mathematics)FreewareFunction (mathematics)Extreme programmingBuffer overflowIntegerRevision controlCoefficient of determinationServer (computing)Computer fileGoodness of fitScripting languageCASE <Informatik>Power (physics)Right angleCausalityPhysical systemProjective planeBuildingWeb crawlerSimilarity (geometry)Content (media)Cartesian coordinate systemInformationUnit testingSoftware testingCodeAverageAnalytic continuationResultantDirectory service2 (number)Computer networkComputer animationLecture/Conference
29:07
Software developerDefault (computer science)Revision controlBootingConnected spaceStability theoryMereologyComputer architectureScripting languageResultantInternetworkingGraph (mathematics)Lecture/Conference
30:26
Software developerMessage passingComputer fileDefault (computer science)Content (media)BuildingTraffic reportingMultiplication signMereologySoftware developerLine (geometry)Source code
31:10
Software developerMultiplicationView (database)Similarity (geometry)CASE <Informatik>HoaxCodeElectronic mailing listFunction (mathematics)Thread (computing)Default (computer science)Text editorPlug-in (computing)Computer fileVisualization (computer graphics)BuildingMessage passingResultantInstallation artComputer configurationSoftware developerError messageRight angleTouchscreenControl flowProcess (computing)BlogLine (geometry)CausalityClique problemSystem callRoundness (object)Letterpress printingFilm editing
34:54
Software developerFunctional programmingSimilarity (geometry)Multiplication signQuicksortVisualization (computer graphics)Set (mathematics)CodeText editorType theoryExtension (kinesiology)Term (mathematics)Plug-in (computing)Programming languageServer (computing)Scripting languageBitVariable (mathematics)Web 2.0Projective planeProduct (business)PlastikkarteMultilaterationNormal (geometry)Context awarenessMusical ensembleSource codeLecture/Conference
38:13
Software developerBuildingScripting languagePhysical systemOpen sourceCodeGroup actionData compressionWater vaporCASE <Informatik>Right angleMathematicsVideo gameFunction (mathematics)Directory serviceMultiplication signLine (geometry)File systemLibrary (computing)Text editorComputer fileSource codeComputer animation
40:09
Software developerElectronic mailing listComputer programmingFunctional programmingTrailOpen sourceSuite (music)Text editorComputing platformError messageDisintegrationPresentation of a groupCuboidExpert systemMereologyElectronic mailing listProgramming paradigmLink (knot theory)Term (mathematics)Web pageProjective planeCore dumpFunctional programmingFunctional programmingPoint (geometry)Computer programWeb 2.0Dependent and independent variablesServer (computing)Computer networkVisualization (computer graphics)Flow separationCodeNormal (geometry)DebuggerInteractive televisionOpen sourceSinc functionFile formatGroup actionRight angleHoaxTrailCASE <Informatik>Function (mathematics)Multiplication signLine (geometry)MappingoutputEndliche ModelltheorieDemosceneForm (programming)Product (business)Metropolitan area networkSoftware bugSource codeComputer animation
Transcript: English(auto-generated)
00:08
Okay, hello everyone, can you hear me well? Okay, fine. I'm Chris and this is Ionite and state of the F-sharp open source ecosystem talk. It will not be very technical talk,
00:22
it will be mostly about F-sharp tooling, some F-sharp projects, some projects which can be used also not only in F-sharp, well they are created in F-sharp, but they can be used in any .net project we have. First of all, how many of you are .net developers?
00:42
Everyone? Okay, that's nice. And F-sharp developers? Yeah, that's also nice. So, about F-sharp, F-sharp is statically typed language from ML family, it's functional first language, suggested way of doing things is functional,
01:02
but if you really want, you can do object-oriented things in it. It's really focused on open source community and it's like community driven, and since it's like functional programming talk and everyone in functional programming has serious like academic background
01:22
and you need really a lot of mathematics in this talk, so I have one really important thing to remember, that open source, it's code and community, so that's like the first important thing I would like to like say in this talk,
01:41
that open source is not only about throwing code on GitHub and just putting it there and thinking, yeah, we are open source. It's also about creating community, it's about supporting people who want to upgrade your tools, upgrade your make contributions,
02:01
who gives feedback to you, and yeah. F-sharp mainly, I will show like few examples of how it is like showing in F-sharp community. The first most important thing is F-sharp Software Foundation,
02:21
which was created in October 2012. It's managing development of F-sharp language, it's formal nonprofit organization, it's officially registered as a nonprofit organization a few days ago. It was really like important thing for community that we have something like that, which take cares of language,
02:42
so it's not only depending on Microsoft or some other commercial vendors, but it's like community thing. We have democratic elections and stuff like that, so it's nice. And second important thing in just language showing that it's like focused on community,
03:02
it's release of F-sharp 4.0. It was total, everything was done on GitHub, everything was discussed on GitHub, everything was done as open source project. There were 38 contributors, over 75% of contributors were not Microsoft employees
03:21
or Microsoft Research employees, so just people from community. Yep. And now I will move and quickly describe two big tools which are very important for F-sharp community. One is Packet, it's like tool for dependency management in .NET space.
03:43
Second one is Fake, but we'll move to it later. So Packet, Packet is alternative NuGet client, which also add some few more features which are really nice. First of all, it ensures solution level versioning
04:01
of our packages, so we don't have any more situation that product A in our solution has new tons of the JSON 6.0 and product B has new tons of the JSON 7.0. I guess everyone who are doing things in .NET
04:21
with NuGet had similar situation before. Second important part is that it has no versions in path. What allows to have no merge conflicts after version update in product files? Probably also everyone have like this situation,
04:41
had like this situation when some developer in team upgraded dependencies like to newer packages versions, NuGet, and there is like 100 merge conflicts in a whole solution because like everything breaks because like versioning paths were hard-coded
05:02
and like stuff is not working nice. So this is fixed in Packet. Second part, it's like, it allows for GitHub dependencies. So you can depend on any project from GitHub and a file from GitHub. It also HTTP dependencies,
05:21
so practically it's any file which is on the internet. It has group features. It's somehow similar to the, like if any of you have ever done NPM packaging, like they have this notion of development dependencies
05:41
and project dependencies, which makes sense since some tools are just like our machine dependencies, like we are using it to build code, not necessary to deploy it to production. So Packet moves a bit further with that idea.
06:02
It allows to just create as many groups as we want so we can have dependencies like main dependencies for our project, build dependencies, testing dependencies, et cetera, et cetera. And in upcoming version three, which is right now in the alpha,
06:23
it adds full Git protocol support. So it's not only limited to GitHub, but also like all Git providers. And this thing, this product we download from GitHub or from any Git repository, we also like Packet will build it for us.
06:42
So it's system similar to other languages. I think Rust using similar system, which like builds stuff which like dependencies are not in binary format in the somewhere in the web, but just in the source format and they are built in the local computer
07:02
after downloading. Yeah, and with stats. So like that Packet is not something new. It's two years old project. It has like ridiculous amount of commits, releases. Really a lot of contributors ask for, like all these numbers needs to take into account
07:21
that this is F-sharp project. It's written in F-sharp or code. So it's not as easy to find contributors to F-sharp project. But as I said before, it's like it supports any .NET project, not only F-sharp. And let's start with some Packet internals,
07:42
how it looks like generally. There are three types of files in Packet. Packet dependencies, it defines our direct dependencies on the level of solution. So we don't have to care about dependencies which are related to other Packets we depend on.
08:06
So for example, if we have normal nougat and Packet.config file, Packet.config file lists all dependencies. We don't know if dependencies listed in Packet.config file for normal nougat client
08:21
are dependencies of like our dependencies or dependencies of this guy whose library I'm using. So basically, Packet uses three files, all of them are editable by hand. They are playing the files with really not a lot of structure.
08:42
As we can see, they are as simple as possible. So they can be used from basically just notepad and command line if we really want to. We define our source. Our source can be, like in this case, it's general nougat fit.
09:00
It can be our private nougat fits or stuff like that. It really doesn't matter. We define our dependencies. Of course, we can have any inclinations that our dependency needs to be like version 0.7
09:23
or one greater than 1.2 but always lower than two so not updating major version. It's like all following somewhere standard. Second file is Packet log file.
09:42
It's fully resolved graph of dependencies. So here we can see our indirect dependencies with exact versions we are using with everything. This is basically a very similar file to packages.config file for normal nougat
10:01
but it has also this nice indication that what package depends on what, on which. And this file is automatically computed by Packet. We don't have to create it by hand. We just run Packet.exe with parameter install
10:25
and it just creates this thing. Resolves everything from nougat, like downloads all packages information from nougat and yeah, put this stuff together. And third file, those two files,
10:41
Packet dependencies and Packet log are our solution level files. So they are usually in solution root folder or in repository root folder depending on structure of the project. And last type of file is Packet references. It specifies which dependencies are used in given products.
11:03
So there is one Packet references per project usually and it also only specifies direct dependencies so we don't have to take care of this indirect stuff which we really don't care. Like if we want something, we just specify it.
11:21
If it's not something we want, we shouldn't care about it. It should be taken, care should be taken by tool. And maybe I will show also how it looks like. Yeah, this is for example, typical Packet dependencies file
11:42
for ASP web API 2.0 hosted on Owen. So with startup file, not with global space, this stuff. So in Packet dependencies in solution,
12:00
as we can see, it's like solution level file. We specify our direct dependencies. We also create secondary group. We call it test, those are all our test dependencies. We want to have them. Using Packet install,
12:33
basically, well, here is everything up to date but normally it's just ask nougats for versions,
12:41
for like dependencies and all this stuff and resolves it creating this amazing file which as we can see has many more dependencies than our direct dependency file. And last type of file is Packet references which this time for every project have,
13:03
we have one Packet references file. So yeah, we're in this place where we need testing or we only like list test dependencies. Here we list our other dependencies we want
13:20
in this ASP web API project. So summing up about Packet, it's really nice tool, alternative nougat client. It also allows really a lot of other stuff. I really suggested using it also for every C Sharp project
13:43
since it's really, I think, most sane way of doing dependency management at .NET platform right now but that's just my opinion. Feel free to test it out on one project and like see how it goes. There's also convert from nougat option.
14:00
So if you have like your existing solution, you can easily convert it to nougat. There are people who are like in testimonials saying that in testimonials on Packet website, they are saying that they had like 100 projects in solutions and easily converted it to Packet and everything was working.
14:20
So yeah, hopefully you will like it. Fake. Fake is F-sharp make like F-sharp community has this talent for really nice names like fake, fuck it or and stuff like that.
14:41
So fake is built automation system. It's domain specific language built on top of F-sharp. It has helpers for everything in .NET space starting from like nUnit, xUnit, this normal testing stuff to CI systems, to packaging, to even not only for .NET space
15:03
but it also right now has helpers for things like NPM or Bower. So it's really, really, really crazy tool. It's very mature tool. It's over five years old. It also have really big numbers of contributors, like releases.
15:23
Yeah, who is using it? For example, Akka.net. So C-sharp product basically. Octokit.net by GitHub, C-sharp project. Elasticcert.net by Elasticsearch, C-sharp project. And multiple commercial projects and almost everyone in F-sharp community also
15:42
but I wanted to like to show that it's not only a tool for F-sharp people, those crazy guys, but also for normal C-sharp enterprise C developers. Running fake. We usually, whoops. We usually creates,
16:04
usually creates built normal command line script very short which just executes fake. Fake is usually download from NuGet, usually using packets since it's like,
16:20
since there is no version number here in this place, we can easily have path to fake in this place. With normal NuGet clients, there will be always path version in this path and we would need to upgrade this build command line thing every time. And we just pass build F-sharp script file to it
16:45
and some additional parameters if necessary. Whoops. There are a few, like I will have here a few examples of how to do really common tasks which usually we have in our build process.
17:03
First one is cleaning. There is really nice clean deer helper which just removes everything from directory where we pass as parameter. And yeah, that's basically how looks fake, this build fake file. We define a set of targets
17:21
which are just F-sharp functions. Usually, like we don't really need to have advanced F-sharp skills since most of the time we use built-in helpers. We don't really write any complex codes. It's just, basically it's just domain specific language more than using F-sharp as F-sharp.
17:43
And we define graph of dependencies how our task should be run one after another. It can be, it doesn't have to be one list. It can be graph. It's also resolved by fake internally. It supports such things as caching
18:02
so if something, so if fake somehow knows that this part of build was not affected by changes we've done in our project, it would not run this part of build again. It supports parallel building so it detects that if tasks can be run parallel
18:21
because they are depending on each other and they are like, they can be just run in parallel. Building, building is, yeah. We have this nice operator, two exclamation marks which basically we provide a path to our CS project file,
18:44
to our FS project file, to our VB project file, to our Nirmala if anyone is using file. And we pipe it to command MS build release. In this case there are MS build debug. There is like MS build command with really a lot
19:04
of possible parameters. Basically everything we can do with MS build in command line so what is normally Visual Studio doing for us we can also do here. And as we can see that's pretty simple
19:22
and we again define our dependencies. Testing, it's very similar. There are, as I said, there are helpers for any unit. There are helpers for X units. There are helpers for everything I guess. And if really there is no helper for anything
19:42
you should just tweet about it or like write on Stack Overflow and there will be nice person which will create this helper for you. Because Fsharp community is really, really active and really like takes care of both packet and fake as this most important projects in the community.
20:02
Okay, and now we will move to the most important thing and actually why I'm here. This is Ionite. Ionite is product I've created I think like 10 months ago, 11 months ago. Basically it started as Fsharp plugin for Atom Editor
20:21
but with time it grows and is now really complex tool supporting both Atom Editor so it's like anyone doesn't know what is Atom. Okay, oh, you don't know, okay. Atom Editor is like text editor created by GitHub. It's text editor very similar to Sublime Text
20:42
with this command palette. I will show some demo in the moment with command palette user experience based on this. Visual Studio Code is very similar to that. It's created by Microsoft because why not?
21:00
Yeah, both tools are very similar. They are both based on JavaScript. So those are JavaScript applications running on desktop using Chromium engine. So writing extensions for Atom Editor and Visual Studio Code should be writing JavaScript or CoffeeScript
21:22
or TypeScript, stuff like that. In case of our project, we write our extensions in Fsharp and compile it to JavaScript because it's easier to find contributors who cares about,
21:41
like people who cares about Fsharp tooling are Fsharp developers so it's easier if this tooling is written in Fsharp so it's easier to make them contribute if I had to find like Fsharp developer who cares about tooling, who also fluently writes CoffeeScript, it would be like probably really hard.
22:03
And thanks to that, that it's in Fsharp, I have reasonably lot of contributors ask for tooling project, tooling projects are not really popular in communities. People likes them if they are like good and ready but don't like to contribute it to it.
22:23
So yeah, both editors right now support many Fsharp editing features such as auto complete, tool tips, error highlighting, syntax highlighting, any stuff you would like to see in modern development environment. Both have packet and fake integration.
22:42
It's very important right now, it's very important point for me that my project integrates really well with stuff that community creates so with all popular projects in community. So for example, and it's very opinionated so for example we don't support normal MSBuild builds
23:03
like Visual Studio but just we require people to write their builds in fake. It may be not the best solution but it's like I guess most popular solution in Fsharp community so that's why we are using it. It's integrate with Fsharp Yeoman generator.
23:23
Yeoman, everyone knows what is Yeoman? Someone doesn't know? Okay, Yeoman is like this tool from JavaScript community which is used to scaffolding projects so for example we say create new applications using React
23:42
and it creates like adds dependencies, creates basic product structure and stuff like that. So we've also created similar project for Fsharp. Well, exactly we written a generator for this Yeoman so we can use existing infrastructure for that.
24:04
It can generate several different project types for example, console application library thing, Web API 2 project, WPF application using Fsharp
24:24
and many more, I don't remember them all right now. FSLab, there is about like 15 templates right now. It's like more templates than in Visual Studio out of the box so I think it's like good. It has also other cool features which I will show in a moment.
24:43
Who is using this thing? So Atom Fsharp plugin have over 13,000 downloads for 10 months old project. Visual Studio Code plugin have 3,000 downloads
25:00
for two months old project. It was pretty nice from Microsoft that I was able also to take part in beta, really alpha preview of their plugin system so we could like deploy, deploy release our plugins for Visual Studio Code
25:21
in day one so yeah, before it was like publicly, publicly available for the community to create products. That was pretty nice from Microsoft. Okay, some demos. Let's start with command line.
25:44
I will for a moment get back to fake. Okay, as I said, usually we create build.cmd file or build.sh file for Linux systems since both tours,
26:04
packet and fake are cross-platform tools and they can be used on any operating systems right now. Basically such build contains of three parts. So first part is running Packet Bootstrapper executable which downloads newest, latest version of Packet
26:23
which is really important since Packet is like released, new version is released one per day by average or maybe two per days. So like it's really this continuous deployment mentality to the extreme.
26:40
Second part of our build process is running Packet Restore which downloads every dependency from NuGet, from GitHub, whatever we have specified in our Packet dependencies, things and lastly we run a fake with our script file
27:01
and in this case script files usually always have similar structure. Firstly, we have few variables which like defines our names, directory names, our name of our project
27:21
on GitHub, stuff like that and then we define targets. First target is cleaning our old directories which are reported for us. Second one is building application and in meantime it creates also assembly info file.
27:41
How often do you forget about updating assembly info file when you like deploying new application? It happens like probably every two releases for me and here I can have like write version put into assembly, assembly info file
28:01
and this version is taken either from CI server or from release notes files, whatever you really want and we build this application. First step is building test because like our application is very simple, like very simple code
28:21
and we also have a new unit test which like test if adding works well in .NET. Spoiler, it does unless you overflow integer.
28:41
We run this unit test using a unit helper. We like define that we put output test results into like file, XML file and the last step is deploying this. Well, in this simple case deploying is just zipping our download, yep, and we define dependencies.
29:06
Yep, and how it looks like, sorry. Yep, right now it like Packet Bootstrapper
29:22
tries to download latest stable version of Packet Exa. Hopefully it will work well. I'm not sure how we are with internet connection but it should work, hopefully. Okay, let's assume it won't work.
29:49
Yep, I've terminated only this Bootstrapper part so it uses this version which was download earlier. Yeah, too fast, too fast.
30:04
Here in this part it checks versions of like it tries this running this Packet Restore. Since all versions are okay, everything, nothing has to be download from the nougat and here we start our fake script.
30:25
This is like resolved dependency graph for our target we've chosen. Also in the buildfs6 file earlier we defined that default target is deployed so if I don't pass target name to the build command
30:42
it will just run default target. Starting target clean, deleting contents, finish target clean. All this build process is in similar steps and in the end we have nice summary build report that everything was okay, how much time did every part
31:05
taken and what was total time. But running this from command line is pretty like, it's maybe like popular way right now because everyone is using command line
31:21
but for me XC Sharp developer who for like 10 years developed in Visual Studio and everything was right to right click, run or right click build. I would like to have some more integrated story with that and we have it in Visual Studio Code for example.
31:44
In Visual Studio Code extensions, Visual Studio Code is this text editor from Microsoft, it's really nice, it's based on JavaScript HTML but they've done really good job with it
32:01
so it's really like fast and doesn't have a lot of problems. I've provided three plugins for Visual Studio Code right now, there are six plugins for Atom and there is one big installer for Atom, unfortunately this option is not supported yet
32:20
in Visual Studio Code but they assured me that it will be added later. So in case of Atom we just download Ionite installer and it installs all my plugins and all dependencies. In case of Visual Studio Code unfortunately right now it has to be done by hand.
32:40
There are three plugins, ionite-fake, ionite-fwrap and ionite-packet. And ionite-fake basically adds three commands to command palette, fake build, fake build default and fake cancel. If we press fake build we get list of all targets
33:04
which are defined in our build file which is pretty nice. Yep, I can run deploy from here, get nice message and this whole output which normally is in command line I have on this panel in the Visual Studio
33:22
so everything is in editor, I don't have to leave editor, don't have to move to command line and press. I won't make a typo in my build target because I have list of my build targets and as we can see it was build completed,
33:44
result is okay as it was before. We have also commands for packet. There are multiple commands for packet because packet is more complex tool from the user standpoint of view
34:03
so user can do really a lot of stuff with it. Mainly most important are add nougat package which can add fake for example. And we have similar user experience
34:24
as in case of fake so we have whole output of our normally run in command line packet, whole packet output here in editor. We have nice error messages and threads messages
34:41
on the screen if something breaks so we know what's happening and everything is in editor. Okay, this is Visual Studio Code and now let's try Atom.
35:02
Similar set of functionalities is implemented for Atom editor. Atom is slower than Visual Studio Code unfortunately. Generally Visual Studio Code is in my opinion
35:20
better designed than Atom for similar type of extensions as I write so this rich language features Atom is really great for writing just like normal plugins focusing on text editing. It's not as good in terms of language,
35:41
new language support. Okay, this time we have a bit more complex maybe packet dependencies. Our packet dependencies are rather simple.
36:01
There are two dependencies on FSLab project which is a product created by Tomas. It's project focused on data science and like things for smart people. We have of course dependency on fake as always
36:21
and we have dependency on SWAF. SWAF is lightweight F-sharp web server which is getting really popular in F-sharp community. It's really nice tool and I will like mention it also bit later. Yeah, this is another example
36:40
which can clearly show what is advantages of specifying only like direct dependencies since we specify only FSLab since this is what is interesting and FSLab depends on 20 other packages and 20 other different things
37:01
and we wouldn't want to care about it actually. Updating it is not our problem. It should be problem of tool. We only care about depending on FSLab.
37:23
Okay, and now build script. Build script is a bit more complex but yeah, I will not go too much into details because it's like F-sharp code and it's not really important. What I want to show is that, oh, for example,
37:42
we have our nice tool tips with types of variables and functions inside of Atom editor so not only Visual Studio Code or Xamarin Studio but also we can have this rich user experience for F-sharp editing inside of Atom.
38:02
Similar thing works in Visual Studio Code. Okay, right now I'm in this build script
38:22
I have defined target which continuously run which basically runs a watcher on the file system watcher which looks for all changes in given directory
38:40
and if something has changed it reruns some action. In our case, this action is creating HTML file based on F-sharp script file. So this is F-sharp script file.
39:01
This file is exactly like as we can see these commands here in the right panel are text of the left thing. And here we have some source code and the source code is also inlined in our HTML output.
39:23
This is all pretty cool. Like many of these things is provided by Thomas tool, FSLab. What I've done, I've taken it and put it in editor so you don't have to leave editor, you don't have to move to browser, you don't have to move to command line.
39:41
So everything you want to do is inside editor. So it's as best user experience as possible. Yeah, and for example also it supports live reloading. So if we edit this file and save it will like
40:03
it takes some time because this library is not super efficient and it takes some time. Oh yeah, it's really, yeah, and as we can see now we have five columns here. Yep, and let's go back to the presentation.
40:23
Yep, and now let's move to the future. This is my 2016 watch list in terms of F-sharp open source ecosystem. So first point is running F-sharp on core CLR. It's happening right now, some works are done. So hopefully in the near future
40:43
we will be able to run F-sharp on core CLR. Right now we can run F-sharp obviously on Linux using mono project, but for some reason it may not be like good for our use case and core CLR may be better.
41:02
Second part is SWAF project. As I've mentioned before SWAF is this F-sharp web server. It's really nice since it's using functional paradigm to creating web server since basically web server is always HTTP request and returning HTTP response.
41:23
It can be mapped basically as a function since it has clear input, clear output and it's always defined. SWAF is creating HTTP servers using function pipelining and combining functions together.
41:41
Actually I think it will be discussed tomorrow on functional programming club we will have also tomorrow. And third thing is fix. It's new project I've started contributing to. Basically we want to provide unified experience
42:04
for all this tooling also in command line. So right now packet is separate executable, fake is separate executable. Yo-manska folding is requiring NPM to end nodes to work so it's all like these different parts
42:22
and we want to put it in one tool so everything just works out of the box after installing this one tool. Like this tool takes care of updating packets if there are so many releases per day. As I've mentioned we have this
42:42
NDC functional programming club. We have one today, we had one today and we will also have one on Thursday and Friday. It's great opportunity to talk with all speakers of functional programming track. There are mostly people from F-sharp community but there is also like there will be
43:03
at least two talks from Elixir if I'm not wrong. So hopefully they will also show up and it's great opportunity to talk with all those smart guys. And we're planning some, basically today
43:21
we have small discussion and after it we divided into groups so like every group like had one expert which was focused on one topic and people were like asking him questions and things like that. So it was I think really nice and even if you don't really want to learn anything
43:44
it's just like we are great to hang out so just to talk. Any questions? Yes, it's supported in both Atom and...
44:04
Oh yes, question was about F-sharp interactive in Ionite. F-sharp interactive is supported in both Atom and Visual Studio Code. In both cases F-sharp interactive panel is read only so only way you interact with it
44:21
is by using send line or send selected text to the F-sharp interactive and on F-sharp interactive panel you have output from interactive. Yes? No, no that's just some kind of formats.
44:46
Yeah, question was is that F-sharp, yes? This one or this one? No, this is not F-sharp.
45:00
So the question is if debugging is supported? No, unfortunately, wait. Debugging is supported on Visual Studio Code on Linux and Macintosh only for Mono since Microsoft provided Mono debugger for Visual Studio Code. Microsoft right now doesn't provide
45:22
normal .NET debugger for Visual Studio Code and no one created .NET debugger for Atom and I don't think it will ever be created. Hopefully just Microsoft will add,
45:43
well if there is .NET debugging in Visual Studio Code then F-sharp is supported since it uses normal .NET debugger so hopefully Microsoft will provide or someone else from community will provide debugger for .NET, general .NET so C-sharp visual basic
46:01
and we will also have then debugging for F-sharp. Yep, anything like more questions? Okay, so if there are no questions. At the end of my presentation there are two pages of links.
46:21
One is with links to those projects I've talked today. Second one is with more about F-sharp. I strongly recommend joining fpachat.com. It's really nice community for functional programmers. It's Slack chat. I think everyone are using Slack here.
46:43
So yeah, and that's all. This presentation will be somewhere online. I will tweet it with NDC London hashtag so you will be able to find it. Thank you very much.