Last Friday we released MonoDevelop 2.0 alpha 2. This is an exciting release because for the first time it includes debugger integration. This integration is not yet perfect, the debugger is not yet 100% stable and not all features are available, but we finally have some debugging support. This has been the #1 feature request for long time. You can take a look at my previous post about the debugger to get an idea of what it looks like.

In addition to the Mono Debugger (MDB), I also have spent some time improving the GDB integration. We now have support for expression evaluation, which can be used in conditional breakpoints and tracepoints. The debugging service in MonoDevelop is extensible, so we can plug support for different debuggers into it. I hope we can add support for debugging other non-.net based languages in the future.

Anyway, here is a screenshot of a debug tooltip in a GDB debug session:



The other big improvement in alpha 2 is the new code completion engine, on which Mike Krueger has been working. The new engine supports "aggresive" code completion, which means that the completion window will be shown in any context by just typing the first char of an identifier. It also has some nice features such as automatic insertion of event handlers or anonymous methods when completing an event subscription. In addition, the C# parser has been upgraded to support C# 3, and we already support some of the new C# features, such as completion of extension methods. The new engine still needs polishing and performance improvements, but it is looking great.



Michael Hutchinson has done a great job improving the editing experience for ASP.NET, HTML and XML files. There is better support for code completion and CodeBehind files. Compatibility with Visual Studio 2008 has improved, and we now have preliminary support for creating Moonlight projects. Many hackers will also be interested in the new vi mode that has been implemented for the text editor.

The GTK# designer has also some improvements. Mike Kestner became the maintainer of the designer some months ago, and he's been learning about the inner workings, and doing some fixes and improvements. One of the main changes is the simplification of the GTK# settings panel. It is not necessary to explicitly enable GTK# support on projects in order to use the designer. Now it can be done by just adding a reference to GTK#. Also, exporting a widget so it can be used in another project is as simple as applying a [ToolboxItem] attribute to the widget class.

Ankit Jain did a great job with the new Override/Implement dialog, which allows to easily implement members defined in a base class or interface. Here is a screenhot:



Ankit is now working behind the scenes to complete xbuild, our MSBuild implementation. The mid term plan is to replace MD's build system by xbuild, but this won't happen before MD 2.0.

There are many other improvements in version control support, project management and others, but you'll have to take a look at the release notes to know more.

In the following weeks we are going to focus on bug fixing, and we plan to release a 2.0 Beta 1 soon (the plan was to release before Christmas, but holidays may not permit it). In the meanwhile I hope you find alpha 2 useful and file any bug you can find so we can fix it to make MD 2.0 an awesome release.

Since my girlfriend wants to learn English and I'll probably have to attend a meeting in Boston, we decided to put it all together and we are planning to stay a couple of months in Boston, from end October to end December. After 5 years working alone at home, it will be refreshing to work in an office together with non-virtual coworkers. It also comes at a good timing because we are planning to release MonoDevelop 2.0 around the end of the year.

This is going to be an interesting end of year.

BTW, I'm currently looking for a small apartment (or big room) to rent, ideally around Cambridge. Unfortunately I'm not having much success, since apartments I found are either too expensive, or not available for those two months. So if you know about some good place, information will he highly appreciated! (mail lluis at novell dot com).

The debugger integration in MonoDevelop is progressing, lots of work in the past weeks. I'm going to show what is supported right now, altough much work is still left to make everything stable.

Everything I'm showing here works both for the MDB and GDB backends, unless explicitly stated.

First of all, this is the Attach to Process window. Notice the "Debugger" combo at the bottom. It allows you selecting which debugger you want to use to start the debug session (MDB or GDB):



Breakpoints have a nicer look, and there is support for enabling/disabling. Also, when starting a debug session, invalid breakpoints (e.g. breakpoints placed in lines without statements) will be rendered as disabled.



The dissassembly window shows the assembler mixed with the source code when available. This mixed view is not supported in MDB, due to limitations in the API (for MDB, dissassembly without source code will be shown). The disassembly view supports single-stepping of assembler instructions.



Big improvements in the Watch View. The list now has icons for each type of member. Drill down has been improved, for example big arrays are now split in 'ranges' which makes easier to locate elements.

The Watch View now supports expressions. The expression evaluator is based on NRefactory, and although not all C# expressions are supported, many of them are (for example, arithmetic operations, method calls, array access, conditional expressions, etc). Expressions can be used both to select what to show in the view, and to assign values to variables or members. For GDB, the GDB expression evaluator is used. The screenshot below shows some examples. In one of the examples, the value of an expression will be assigned to the variable 'n':



The Watch View can also be used to inspect types. The view will show all static members of a type. Namespaces are also supported. For example, you can enter the namespace 'System' and drill down through all types and inspect their static members (not supported in GDB):



The Watch View also supports code completion (both for entering expressions and values). Code completion is based on data from the debugger backend, not on the MonoDevelop parser database, so it works for MDB and GDB, and even when debugging an application for which there isn't a MonoDevelop project:



Another nice feature is the support for debug tooltips in the editor. When moving the mouse over a variable or member, a tooltip will show its value. The tooltip is interactive and allows drilling down and modifying values just like the watch window:



It is also possible to use tooltips to inspect the value of expressions:



And works for GDB too! This final screenshot shows a Mono process attached with GDB, a debug tooltip for a MonoMethod, and a member of that struct being modified using code completion:



That's all for now. If you want to try it you'll have to get everything from SVN (see my last post).

Many people has been asking about the status of the debugger integration in MonoDevelop, so I thought it would be a good idea to post a quick status report.

The short answer is that we are working on it. The debugger integration work has started, and there is already support for breakpoints, stepping, call stack view, current frame selection, basic variable watch window, and attaching/detaching to/from running processes. All this is working in MonoDevelop from SVN (still with some stability issues).

And here are some big news: we are integrating not only MDB (the Mono debugger), but also GDB, and thanks to the debugger abstraction layer we built in MD, we'll be able to use the same GUI for both debuggers. Two debuggers for the price of one!

We are going to do a MonoDevelop release next week. However, this release will not include the debugger integration because it still depends on Mono and MDB from SVN and we would not be able to package it. If you want to try the debugger (beware, this is work in progress), you have to do the following:

• Get and build Mono from SVN.
• Get and build the Mono Debugger from SVN.
• Get MonoDevelop from SVN.
• At the MonoDevelop's top-level directory, run './configure --select'. Make sure the extras/MonoDevelop.Debugger.Mdb add-in is selected (and/or extras/MonoDevelop.Debugger.Gdb if you want GDB support).
• Build MonoDevelop.
  

If you only want to try GDB, you don't need Mono and MonoDebugger from SVN, getting latest MonoDevelop is enough.

Last Friday MonoDevelop 1.0 was released. It is the first time I do an 1.0 release, so it is really exciting to see the release after so much time working on it. To know more about the features of MD, take a look at the release announcement. Miguel also wrote a nice blog entry about the past and future of MD.

Our main goal for this release has been to provide a good IDE for developing applications for GNOME and the Linux desktop in general. Most of the features are being use nowadays to develop MD itself: the GTK# designer, Subversion integration, Makefile integration, unit testing, localization, and others. It means that MD is mature and complete enough to handle complex projects, and that's why we have an 1.0 release right now. This release is of course not perfect, there are still bugs and feature gaps, we'll keep working on it.

So what now? we are already working on next release, which should happen in about 6 months, and which will include long awaited new features, such as debugger integration, code folding, better ASP.NET support, and many other improvements. After so much time being focused on bug fixing, it is a pleasure to go back to real hacking :)

Last week we released MonoDevelop 1.0 RC1, the (hopefully) last release before 1.0. This is a bug fix release, with no real new features, so the release notes are a bit boring this time. There is however a nice improvement: many icons have been redesigned to better fit the Tango style, so MonoDevelop now looks nicer. Those icons were designed by Vincent Depizzol as part of a GHOP project. We had other GHOP collaborations, such as for example new translations, I hope Michael can find the time to blog soon about all of them.



In addition to bug fixing, we are also starting to do some post-1.0 work in SVN trunk. Mike has been working on a new managed editor, fully implemented in C#, and it progressing very well. Ankit has started doing some preliminary work on the debugger integration, and I've been doing an internal redesign of the project model which will allows us to move to MSBuild as default file format. After so much time being focused on bug fixing, it is refreshing to start implementing new features.

I spent last week working on the add-in authoring extension for MonoDevelop, which has been stalling in my hard disk since I blogged about it almost one year ago. The add-in is not yet ready to be used, but it is close, and the code is finally in SVN. Let's see if I can find the time to finish it. So many things to do...