Project description

In this post, I will describe what my project is all about. What is it that I intend to do, why do I intend to do it, and how?

Haskell is a pure functional programming language. Pure functional means that the entire program is treated as the evaluation of an expression; the word pure indicates that such an expression can have no side effects. Hence, no modification of variables, no reading from disk, no drawing to the screen. Of course Haskell wouldn’t be very useful if it couldn’t do all those things, but indeed it can. The language is now growing out from its origins in computer science research, as more and more people begin to realize that purity and strict typing are good things. Although the initial effort that goes into a program may be a bit more than with more mainstream languages, these language features guarantee a certain degree of correctness that impure, dynamically typed, or imperative languages can never achieve.

However, I believe that the further acceptance of Haskell is held back by a lack of tooling. There is an great compiler, great libraries and a great package management system, but there is no really great IDE (Integrated Development Environment). A good IDE would not only be a great time saver for seasoned Haskell developers; it would also be of much assistance to newbies who want to learn the language.

There is Leksah (Haskell spelled backwards, missing an L), but it is still under heavy development and not yet in a really usable state. Yi is an editor written in Haskell, but it does not qualify as a full IDE. Either way, there is no reason to build yet another IDE from scratch when a perfectly good option is readily available.

Eclipse is one of the most popular IDEs  for the imperative programming language Java, and it is also written in Java. I worked with it years ago and hated it. It was unwieldy, incomprehensible and terribly slow to boot. But recently I was forced to work with it again, and I was pleasantly surprised. Because it is a very powerful IDE there are still many knobs and dials, but they are generally in sensible places and can be understood without a manual. The speed has also improved greatly. But the best thing about Eclipse is its feature set. It has clever code completion. It has a powerful build system. It has refactoring features that outdo even the latest Visual Studio releases from Microsoft. And it is not just about Java: rumour has it that Eclipse can also be used for C++ development, PHP… and Haskell.

Indeed it can. EclipseFP (which stands for Eclipse Functional Programming) is a plugin for Eclipse that allows for Haskell development. (It also contains discontinued support for OCaml.) Unfortunately, EclipseFP is only marginally usable, does not offer half as many useful features as it could, and has been standing still for almost a year. I figured that’s a shame, so I decided to try and see if I could improve this situation. Thomas Schilling a.k.a. nominolo has graciously offered to be my mentor, for which I am vary grateful. Leif Frenzel, the original author of EclipseFP, has also offered his help, so I am in good hands.

I will start by fixing small bugs and making little improvements here and there. This way, I will familiarize myself with the source code of EclipseFP and with the Eclipse plugin system.

Next, the real work will start. The current EclipseFP does its own parsing of Haskell, which is a duplication of work: there is already a perfectly good Haskell parser and typechecker available in the form of the compiler, GHC. The Scion library was developed (by the aforementioned nominolo) specifically for interfacing with GHC. Thus, my next course of action will be to hook EclipseFP up to Scion.

This opens up many exciting possibilities. The type of an identifier could be shown in a tooltip when you hover the mouse cursor over it. Inferred type signatures could be automatically added to functions. Type errors and other compile errors could be highlighted with red squiggly lines. It could be possible to Ctrl+click on an identifier to jump to its definition.

Near the end of the project, I will add support for the Haskell package manager and build system Cabal. EclipseFP currently uses its own build files, but using a Cabal file would greatly simplify the transition to Eclipse + EclipseFP and also allow for easier integration with existing libraries. Some IDE support in writing the Cabal file would also be great.

So, that’s the plan for the next months. It will be a bumpy ride. It will be difficult at times. But I’m definitely going to learn a lot, and will hopefully even turn out a useful product!


About me

I figured that the readers of this blog might want to know some more about me. If not, you can skip to the real stuff.

My name is Thomas ten Cate. I’m a 24-year-old Computer Science student at the University of Groningen, a wonderful town in the north of the Netherlands where I also live. I am about to finish my Master’s degree in CS, and I also have a Bachelor’s degree in mathematics.

My programming experience includes a lot of C++, a lot of Java (mainly for teaching) and also a lot of C#. I was taught Haskell in a university course on functional programming years ago. Unfortunately, that course did not go very far, so I have been learning me a real-world Haskell since. I cannot call myself a Haskell expert, but I am beyond the beginner’s level. For example, I do grok monads, but am still hazy on stuff like functors and arrows. I hope to learn much, much more about the language during this Summer of Code project.

Other experience includes half a year at the Interactions Lab at the University of Calgary, Alberta, Canada, which gave me much valuable insight into human-computer interaction that will be useful when modifying and extending the user interface of EclipseFP. Furthermore, I run a one-man open source project called Taekwindow, which you might like if you are occasionally forced to use Windows.

I chose to do this Summer of Code project because I wanted to write something more serious in Haskell than the small programs that I’d toyed with so far. With that desire came the need for a good IDE. Kate is a nice editor, but it will not compile for you, or highlight errors, or run your program. I poked around the web and found that I seemed to be desiring something impossible. Then the Google Summer of Code came along and gave me an opportunity to try and make the impossible possible, so here I am!

Posted in EclipseFP. Tags: . 1 Comment »

EclipseFP project accepted for GSoC 2009!

I’m happy to announce that my Google Summer of Code proposal, titled “Extend EclipseFP functionality for Haskell”, has been accepted! For the uninitiated, GSoC is a project in which Google sponsors a number of students each year to work on open source software. During the upcoming three months or so, I will be working on improving EclipseFP. In this blog, I will track my progress.

The target audience for this blog are Haskell programmers, Eclipse developers and any other software developer who happens to be interested. I will try to keep it readable for all interested parties, but it might sometimes get quite technical; in that case, feel free to ask what the hell I’m talking about, or just ignore me. Incidentally, I also just sent out a request to Planet Haskell and Planet Eclipse for this blog to be syndicated.

Anyway, since I target a fairly general audience, I have some explaining to do. In a next post, I describe what my project aims to do, how I want to accomplish it, and why I think it is important. But first, allow me to introduce myself.