Ionide, based on the Atom Editor, is a suite of packages that aim to provide a full-featured, modern, cross-platform, open-source IDE for F# development.
Ionide is written in F# (transpiled to JavaScript) and its main features include:
- syntax highlighting
- error highlighting
- autocompletion
- tooltips
- integration with F# Interactive, which provides a REPL environment.
Ionide also integrates with several projects created by the F# community to provide more advanced features such as:
- Project creation, using F# Yeoman Generator which provides multiple templates for popular project types.
- Package management through Paket, which allows to add, install, update, and remove packages, and list outdated packages.
- Target building, using FAKE, with build output displayed in an integrated panel.
Ionide is available on GitHub and can be installed on Linux, OS X, and Windows, using the Atom package installer.
InfoQ has talked with Ionide’s creator, Krzysztof Cieślak.
Can you explain what motivated you to create Ionide?
First of all, I was looking for an interesting OSS topic to invest some time into. The F# community is really active in terms of pragmatic and productive OSS projects, so I wanted to do something useful for the community that I find really nice and positive and generally does a lot of amazing things. Secondly, I was getting a bit annoyed with Visual Studio - while it’s a really good IDE for C# and F# (once you’ve installed the Visual F# Power Tools Extension - another very interesting F# OSS project) it’s not perfect for all use cases.
F# is great for developing applications using more “lightweight” interactive style, using the F# REPL - FSI(F# Interactive). I was looking for an alternative for some time, but I’m neither a Vim nor an Emacs user (which both have good F# support) and Sublime Text F# support was not as good as I wanted. So one day I just asked on Twitter if anyone would be interested in F# support for Github’s Atom text editor and there was really positive response. Most importantly there was a very interesting suggestion from Tomas Petricek - one of the really famous F# gurus - that it might be possible to develop the plugin itself in F# (Atom plugins are typically written in Javascript or Coffeescript). So I created a repository on GitHub and start playing with Atom API and FsAutoComplete (the commandline F# backend used to interact with the FSharp.Compiler.Service by editors without access to the .Net framework e.g. Vim & Emacs).
What requirement does it fulfill?
I want to provide the option of a lightweight cross-platform editor for programmers who don’t want to rely on Visual Studio or Xamarin Studio for every project. Such full-featured IDE are not a necessity for F# development, and if all you’re interested in is F# development they’re filled with GBs of features you neither want nor need. VS w/ VFPT and XS both have amazing F# support - much better in terms of plain language support features - but there are many programmers who prefer a different style of tools, especially those coming from a Functional Programming background. A great thing about plugin development for Atom is its flexibility, so I was able to provide in-editor support for other popular and interesting tools used and created by the F# community - Paket, FAKE, and F# yeoman generator.
What is Ionide’s maturity level?
Ionide is a 6 month old open source project created by just a few people, so I definitely wouldn’t call it a “mature” product. There are some rough edges, some useful features from VS / XS still aren’t supported yet (for example auto-editing of project files) and some other probably won’t be supported anytime soon (like debugging, but FSI makes that less important). The Ionide project is under very active development and we make an effort to add and improve features regularly and address user’s issues promptly. It’s hard to say when a text editor is really “ready for production”, it depends on the set of features you think you need. Ionide isn’t at the point yet where I’d recommend it as the only tool for team of F# developers working on a commercial application, but it’s definitely great as a secondary editor for prototyping, writing scripts, or experimenting with the REPL. Quite frankly opening VS or XS and creating a new project just for that is ridiculous. Personally, I’m using it at work - but I’m bit biased.
Any details about its roadmap?
We haven’t established a long-term roadmap for the project, but there are a few features that we are currently focusing on - within the next few days we plan to release the Ionide-WebPreview panel which will add an in-editor preview of web page to Atom that can used by an assortment of F# tools like FsReveal, FsLab, Suave, or just for general web development (as actually it’s not tightly coupled with any of F# technology). After that the next feature I’m planning to work on is a test runner. Jared Hester, one of the other main contributors, is working on an autocomplete style insertion feature for unicode glyphs. F# source code is in UTF–8 and we know there are people from the more academic / research focused part of community that would like an easier way of writing functions like
let inline Σ (xs:#seq<'a>) :'a = xs |> Seq.reduce (+). He’s also generally working on bringing Ionide closer to feature parity with VS and XS.
Atom is dubbed “the hackable text editor”. Could you tell us a little bit about hacking Atom? Which features of Atom have you relied upon? How did it make your effort easier?
I would definitely call Atom a “hackable text editor” - it has a very good API for plugins and many easy customization options for local users. It’s a Node.js based application, so plugin developers have access to most Node.js modules (so plugins developers don’t have to reinvent the wheel). And even when the API doesn’t support some kind of functionality that you need for your plugin, it’s just HTML + JS so the developer can almost always figure out a way to make it work.
My experience with Atom is bit different than everyone else’s - as I mentioned earlier I’m not using JS or CoffeeScript, but F# and transpiling it to JavaScript using FunScript. Thanks to that I get to leverage the many advantages of a really powerful functional programming language (succinct code, excellent data modeling abstractions, pattern matching, type inference, etc.) against a great plugin API, with the potential for total freedom in customizing editor and providing new functionality, unlike plugin/extension development for VS or XS where you feel like you’re fighting against the IDE’s SDK for every feature. Additionally the fact that we are using F# makes it much easier to find people to contribute to the project (as F# developers are the ones who are most interested in F# tooling ;) ). Another important factor is the Atom team is really great about support - they are iterating and fixing bugs very rapidly, often with more than one update of Atom per day, and they are active particpants in their open Slack channels and on GitHub issues.