Monologue

Unity Technologies: Unity 3 coming soon!

Unity_x0020_Technologies@monologue.go-mono.com — Tue, 09 Mar 2010 20:38:27 GMT

In the�Unite 2009 conference keynote we promised you that Unity would be picking up speed, and it has: Unity has become a powerhouse in the game industry and beyond. Nobody else is as active in democratizing sweet game technology to as many developers, and enabling them to target as many consumers. Unity has been [...]

Craig Dunn: Anatomy of a c# iPhone app (with MonoTouch)

Craig_x0020_Dunn@monologue.go-mono.com — Tue, 09 Mar 2010 09:36:00 GMT

Wow - it has been a long time since my last post... and with good reason ;)

Firstly I've been busily writing (along with Wally, Chris, Martin & Rory) for Wrox' upcoming Professional iPhone Programming with MonoTouch and .NET/C# which is available for pre-order on Amazon. If you are interested in developing for the iPhone using C# and the .NET Framework it should be a great addition to all the resources already out there on the web.

Secondly I've been working on an iPhone app for MIX10 in Las Vegas next week (with help from Chris, Miguel & Geoff). It is now available FREE on the AppStore and has a website at mix10.confapp.com. Whether you are heading to MIX or just curious about C# and MonoTouch on the iPhone, why not download and give it a try?

Since the MIX10.app was first 'announced' on twitter #MIX10 there have been a number of requests for the source code. Unfortunately the source isn't public at the moment, however that doesn't mean we can't talk about "how it works". To start with, the MIX10.app is based on two previous iPhone apps written in C# with MonoTouch, and whose source code is available:

Monospace09 code is on github and is discussed on my blog (and here)
PDC09 is on github and discussed in this post

If you have an Intel Mac (with Snow Leopard) then you can download both the Apple SDK and the MonoTouch trial version for free and get both these C# .NET examples running in the iPhone Simulator for yourself. To deploy on a real iPhone requires certificates and licences (from Apple and Novell/MonoTouch respectively).

MIX10.app
Here's the overall class diagram for the MIX10.app (with the views shown too). Even without seeing the code it's clear that the classes themselves are not overly complex (ie. few methods are required; and inheritance can be leveraged to share common functionality).

The MIX10.app also uses Miguel's MonoTouch.Dialog framwork and he's posted a snippet of code on gist.github which is responsible for this screen (on the left)

And he also posted this code which creates the 'My Schedule' view on the right. Pretty neat use of Linq, eh? I'm not sure I've seen such an expressive user-interface expressed in so few lines of code before...

public class FavoritesViewController : DialogViewController {
  public FavoritesViewController () : base (null) { }
  public override void ViewWillAppear (bool animated)
  {
    var favs = AppDelegate.UserData.GetFavoriteCodes();
    Root = new RootElement ("Favorites") {
      from s in AppDelegate.ConferenceData.Sessions
        where favs.Contains(s.Code)
        group s by s.Start into g
        orderby g.Key
        select new Section (MakeCaption ("", g.Key)) {
          from hs in g
            select (Element) new SessionElement (hs)
        }
    };
  }
}

The object model closely follows the data available from the api.visitmix.com site's OData and RSS feeds. These are plain vanilla C# objects which also run on the server to download and package the data for the iPhone - the object graph is serialized by a .NET application on Windows Server 2003, downloaded by the WebClient class on the iPhone (thanks to MonoTouch) and de-serialized ready for display. A perfect example of the cross-platform possibilities facilitated by MonoTouch and having the .NET framework available on both server and mobile device.

Finally, here's a quick overview of ALL the screens in the app. Did I mention you should give it a try?

...and if you're a Windows Phone Series 7 fan-in-the-making, it should be obvious that having a shared set of services and functionality in C# that can be deployed across iPhones with MonoTouch, and Silverlight/Windows Phone 7 with only UI code needing to be customized is a great way to achieve maximum reach for your apps. The MonoTouch Roadmap is also targetting a Q3 release of MonoDroid, so with a bit of imagination it isn't hard to see where the future of cross-mobile-device development is heading...

Lluis S�nchez : Improving in the MonoDevelop user interface

Lluis_x0020_S�nchez_x0020_@monologue.go-mono.com — Mon, 08 Mar 2010 13:50:00 GMT

In the past weeks (actually, months) I've been doing some changes in the MonoDevelop GUI to make it more functional and better looking. Here is the result:

Before

After

Changes in the Status Bar

Everything started with the idea of removing the status bar, in order to save space in the main window. The plan was to use something similar to Chrome's status popups, which are visible only when there is actual information to show to the user. However, after playing with the idea and thinking about how would it fit in MonoDevelop, I decided to try something else. Instead of removing the status bar, we would make a better use of the space it takes. So in the new GUI I merged the status bar and the bottom dock bar. The dock bar is the area where the title of pads in auto-hide mode are shown (for example, the Test Results pad in the above screenshots). When you hover over the title, the pad is shown in a popup window, with a nice sliding effect. The bottom dock bar is now shown next to the status bar, growing as more space is required.

I also added support for custom pad labels. So for example, the Errors List pad now shows the error and warning count, instead of just the "Errors List" label. In this way pads can show some status information while they are minimized.

Less intrusive output pads

Temporary output pads such as logs for Version Control or Find in Files operations are now shown in autohide mode by default. Until now, those pads were shown docked at the bottom, taking space from the text editor. I also removed the standalone Build Output pad. The build output is now available in the Errors List pad, by clicking on the Build Oputput button:

Visual improvements

A noticeable visual change is that the main window new has a darker background, with some subtle shading effects. The pads look more "physical" and better delimited. The pad toolbars are now integrated in the docking system, improving the overall visual consistency.

Configurable GUI compactness

One thing I learned while working in MonoDevelop is that it is hard to find the right balance in the use of padding between the gui components (specifically, between the components shown in the main window). Using more padding makes the GUI more visually pleasant, and the components are better delimited. On the other hand, padding may be a waste of space when working on small resolutions.

I added a configuration option for selecting the level of compactness of the GUI. There are five levels, from Very Compact to Very Spacious. So for example, the screenshots shown above are using the 'Spacious' level. In that level, there is some padding always visible between the pads, the window borders and the main menu. There is no such padding in 'Normal' mode.

Zoomable tree views

MonoDevelop has an option which allows choosing the font to use for the tree view pads such as the Solution pad or the Class pad. Those trees may be large for big projects, so users find it convenient to use a small font, which allows seeing more information at once.

To make font reduction easier and more handy, I added a Zoom capability to the tree pads. So to zoom, all you have to do is hold the Control key and move the mouse wheel up and down (the standard zoom shortcuts can also be used for this, including Control+0 to reset the zoom). This screenshot shows the solution and class pads with different levels of zoom:

Conclusion

The changes I described are part of an ongoing effort to make MonoDevelop easier to use. There is more to come. It would be great to have feedback on the changes we are doing, so that we can further fine tune the interface for the 2.4 release.

Simon Guindon: Simon says, Diggify MonoTouch app is coming soon to the AppStore

Simon_x0020_Guindon@monologue.go-mono.com — Sun, 07 Mar 2010 21:23:56 GMT

The MonoTouch app Project-D has been unveiled as Diggify and is coming soon to the AppStore.

C�dice Software: Distributed development for Windows programmers

C�dice_x0020_Software@monologue.go-mono.com — Fri, 05 Mar 2010 15:45:00 GMT

Each time someone starts writing on distributed development there are some arcane and obscure commands that immediately show up to specify how the changes have to be popped from or pushed to some freely available internet repository. And that's fine, but most of the developers out there are more used to right menus, dialogs and options than typing on black consoles. So at the end it looks like distributed development is something for open source developers working on Linux, and that's obviously not true.

Let's try to describe the whole picture and how you, as a Windows developer most likely working on a commercial project for your company, can also benefit for the new trend of going distributed.

Your current scenario

So, you're using Visual Studio on a daily basis and committing changes to your version control, getting updates from the rest of the team and potentially creating tons of small feature branches to better isolate your code changes (if you didn't embrace yet branching then I bet it will be a great first step before going distributed, but keep reading to check how it will also benefit you).

You probably have several workspaces to work on different projects or just to focus on different tasks without having to update the whole thing again and again (which should be also fast, but you know?).

So basically you go to one of your working copies, make changes from there, and submit there to your central server at the office which lets you forget about how or where the data is stored and it is powerful enough to run very fast and make your life easy :-P.

What this distributed thing is all about?

It's much simpler than you think. Let's start with a nice scenario: suppose you've decided to work at home for a week, avoiding the daily traffic jam and having some spare time at noon to do a break and practice some sports close to your place, sounds good? (Later I'll describe another not so beautiful scenario).

The situation will be something like the following picture, where you've access to your version control server only through a VPN or network connection.

The main issues you'll face will be:

Connection can be lost, slowing you down, having to reconnect and simply making you lose time.

Connection can be slow: switching to a different branch or simply committing or retrieving changes will be painfully slow.

What's the solution? Going distributed. Imagine you've your own version control server on your laptop, so you don't have to connect to the office's central server anymore, everything will be extremely fast, no waits, no connections being lost! Of course, since your laptop won't be as powerful as the central server, you don't need a full copy of all the repositories but only certain parts of the ones you'll need to work with, so you can keep making changes and then synchronize them back with the central server when you're back at the office or through the network when you decide to send them back.

The advantages are clear:

You can move your laptop from work to home (or whatever different locations you can think of) and you'll always be able to continue working seamlessly.

You won't have to wait for changes to be downloaded to your machine from distant locations through slow and unreliable networks.

You're free to continue making changes having full version control support (hey! You can try a poor's man approach just copying a workspace to your laptop, but then you won't be able to access file history, switch branches, make intermediate commits and all this things you get used to when you have version control).

Alternative scenarios

As a professional developer there are many scenarios where you can benefit from distributed development. The one described above, working at home, is just one of them but there are many other chances like:

Working on the customer's site for some days (or even much longer) and still being able to do controlled changes to the source code.

Attend a demo, event and so on and still be able to try a nice change on the code but doing so in a controlled way.

The multi-site scenario: connecting several teams by using distributed development between their servers.

Hands on lab: what to do next

Once the theory is clear, let's just make it happen. Here're the steps we're going to follow:

Set up a server on your laptop.

Import the repositories you need from the central server.

Start working on your distributed server at your laptop.

Submit your changes back to the central server.

Get changes from the central server.

Set up your own "server"

Depending on the version control system you're using it will require different steps. Let me clarify:

If you're using an open source system like Git you won't have a server as such, it will just be a local copy on a directory (typically your workspace) so set up is fast and easy. You can download the Windows installer from here: http://code.google.com/p/msysgit.

If you plan to use Mercurial you can find the download here: http://mercurial.selenic.com/downloads. Mercurial includes a small HTTP server that allows you to synchronize with other servers and other people to take changes from you.

If you plan to use Plastic SCM you can set up the client and server on your machine in less than 45 seconds as you can see in this video: http://www.youtube.com/watch?v=CVlsVtxZUkk. Plastic is meant to be used from a graphical user interface from day one, so it will be pretty straightforward to use (you know I'm obviously biased here, but just check it and judge it yourself).

Unfortunately for Windows developers out there, Team Foundation Server is out of the picture since it simply does not support the distributed workflow. Although it can be installed in less than 45 minutes :-P.

Your server (whether is a real one or just a directory with a copy like in Git) will hold your replicated data and will let you work with your code while you're disconnected.

Replicate from the central server

Once you've your server set up you need to perform an initial code import from the central server. To make things simpler suppose you're only going to work on a single project while disconnected from the central location. Then you'd have to replicate (or clone depending on your specific SCM jargon) one single repository into your laptop.

Normally you won't replicate the entire repository but only part of it. What does it mean? Your central repo will contain hundreds if not thousands of feature branches, releases and so on, but it will be enough for you to work distributed if you get the main or master branch into your cloned repo.

You can have a very big central repo with many branches like the one on the previous picture but you only need the main one to start working.

So the clone process will just mean replicating the remote main branch into a new local repository on your laptop.

You can do that with Git using the git clone command, or you can do that with Plastic even within Visual Studio as you can see on the following picture.

You can see how I've specified centralserver as the replication source and then a new repository I've just created on my laptop as destination. I click on replicate and the import process starts, as you can see on the following screenshot. (Remember I'm driving the whole process from within Visual Studio 2010).

The initial clone can take a little longer depending on the size of your repos (and the speed of your connection, so it's better if you do it while you're on the same network!), but the good thing is after that all the following operations will be extremely fast.

And once you're done replicating you can browse the changes on your new repository, which will contain all the commits (or changesets depending on your SCM) and labels (tags) coming from the central server.

The version control will keep track of which is the source of each element being replicated. For instance, in the previous screenshot you can see how the selected commit is coming from the remote repository you've just replicated (check the properties tag).

Start working on your laptop disconnected from the central server

You've already completed your initial clone, so it's time to start working on your code without having to be slowed down but your central server.

The pattern I'm going to recommend is using feature branches (or the good-ol branch per task branching pattern as you can find here: http://www.cmcrossroads.com/bradapp/acme/branching).

What does it mean? Well, for every bugfix or new feature you're going to implement you'll create a brand new branch, make your changes there and get them integrated into your main branch (or master or trunk depending on your jargon) later.

It's much, much easier than what you might think. Just google for
feature branches if you need more information on the subject, but it's really simple as you'll see.

Creating a new branch is an easy task on any modern version control tool. I'm showing how to do it with Plastic SCM and Visual Studio: I'm going to create a branch from a given changeset as you can see on the following screenshot. I just right click on the changeset and select create branch from this changeset. Different SCMs will do it on a different way but as soon as they're ready for branching (which is unfortunately not true for all of them), it won't be hard to do.

With Plastic SCM you'll find a dialog like the following where you can specify some extra data about the branch to create like comments, name and so on.

Since I'm just going to fix a bug on the new branch I give it a meaningful name. Note: it's very important to follow some sort of naming convention for feature branches since you're going to deal with a big number of them. My favorite is giving them a certain prefix and then a number, which is directly taken from the associated issue on the bug/issue tracking system.

After the branch has been created your situation will be something like the following:

So next step is just switch your workspace to the branch and start working on it. What does it mean? Well, tell your SCM that the changes you're going to make to fix the code have to go to the branch you've just created. It's not a big deal either!

Now it's the time of doing some real coding, making changes on your code to fix a given bug or issue. Not hard to do using Visual Studio 2010 (ok, or extremely hard depending on the specific bug!).

Visual Studio (from long time ago) comes with the pending checkins perspective to communicate with your version control and find what you've changed. In my example I've just modified a single file and I'm ready to commit it (and even added a meaningful comment to the change).

If you go back to inspecting your repository after your initial commit you'll see something like the following:

A couple of interesting things: first there's a new changeset on your branch and your changeset is not replicated (look at the replication source property on the right).

You can do very useful things like inspect the changes you've just made which is one of the good reasons of having your own version control on your laptop!

You can now easily repeat the process to work on different bug fixes, all starting from a well-known point, creating a branch for each of them.

Send your changes to the central server

You've been working for a while and you've already fixed a couple of bugs, so it's time to send your changes back to the central server. Hook up to your VPN and then push your changes.

In order to do so: the sequence of steps will vary depending on the SCM of choice. In case you're using Plastic SCM you can do it from the branch explorer within Visual Studio, simply select the branch you want to push, right click on it and say "push".

And you're done! Repeat the process for every branch you want to submit.

Getting remote changes

Getting remote changesets from the central server is also pretty straightforward. You'll have to repeat the steps you've completed when setting up your repository but this time instead of getting the entire branch it will only find what's have been modified since the last clone! Faster and easier.

Wrapping up

It's been a pretty fast step by step tutorial but I think I've covered the major concepts involved in replication and even some examples on how to achieve it with a specific tool, all within your beloved Visual Studio and without typing a single command!

Unity Technologies: Unity iPhone 1.6 has left the building!

Unity_x0020_Technologies@monologue.go-mono.com — Fri, 05 Mar 2010 12:46:01 GMT

We’re happy to report that highly awaited and much discussed Unity iPhone 1.6 has been released and is available for download. Yes, it’s exactly that mysterious build that adds generics support, enables multiplayer for iPhone and noticeably shrinks final binary size. You might have seen some trackbacks on Unity forums. So what’s so good about it? Now imagine [...]

Rafael Teixeira: My little library Mono.GetOptions is being abandoned by Mono

Rafael_x0020_Teixeira@monologue.go-mono.com — Thu, 04 Mar 2010 20:47:00 GMT

The biggest lump of code I've contributed to Mono, the Mono.GetOptions library is now being erased from the project.

It wasn't perfect and it's successor Mono.Options is a very capable replacement even if it doesn't do all the tricks Mono.GetOptions did in its prime.

Mono.Options is friendly to C# 3.0 features like lambdas, which allows writing code as terse as Mono.GetOptions allowed without using reflection and being a somewhat large dependency, the two main gripes Miguel had with my little library.

The last of Miguel gripes was about versioning (keeping more than one version in the fold) as some of the needed fixes and planned evolutions for Mono.GetOptions would mean breaking changes, which are better handled by consumers of the library by having distinct major versions with its separate APIs and attached series of minor releases.

That gets even more complex as you consider that Mono.GetOptions evolution also was tied to Mono releases.

If memory doesn't fail me, it was Mono.GetOptions and also other libraries imported into the project like SharpZipLib (which is still a problem as Mono is carrying two versions of it, and in this general cleanup process it is going over now we are trying to get rid of at least one of them), that prompted Miguel to change policy and ask for most non core libraries to be developed and released independently from Mono, even if developed by Mono hackers or used in some Mono utility. Better a package dependency (a soft one if possible) than the maintenance burden of embedded libraries.

Well let me quit reminiscing. Farewell my kid...

But if you are a loyal user of Mono.GetOptions what should you do?
You can:

Migrate to Mono.Options (or even use it's code directly as Miguel advocated some time ago because it is a lot slimmer than my library).
You can keep a copy of a Mono.GetOptions binary around to distribute with your solution (not an option for open source projects that would like to be accepted into Debian/Ubuntu).
Tell me you would like to see Commons.GetOptions, my own fork of it, get on the air and fly high. Version 1.0 of it has just the namespace change in it, so your migration effort would be minimal. See the Managed Commons group for more information.

Have nice developments

Rafael Teixeira: Document Freedom Day '10 is coming

Rafael_x0020_Teixeira@monologue.go-mono.com — Thu, 04 Mar 2010 19:56:00 GMT

Unity Technologies: Unity @ GDC 2010

Unity_x0020_Technologies@monologue.go-mono.com — Thu, 04 Mar 2010 09:59:01 GMT

GDC is nearly upon us, I can’t believe it! We’ve got so much going on at this year’s show ? there will be plenty of chances for people to learn more about Unity throughout next week. I’m going to give you a rundown of where we’ll be and what we’ll be doing. Booth Come by [...]

Unity Technologies: Unity?s Partner Pavilion at GDC 2010

Unity_x0020_Technologies@monologue.go-mono.com — Thu, 04 Mar 2010 09:50:28 GMT

In addition to all of our other GDC activities, we’re going to be joined in our booth with a selection of great partners. This is a win-win opportunity where we’re able to bring some more exposure to these partners and their presence helps our booth to reflect the diverse ecosystem that surrounds our tool and [...]

Miguel de Icaza: Big Day in MonoLand

Miguel_x0020_de_x0020_Icaza@monologue.go-mono.com — Thu, 04 Mar 2010 04:47:00 GMT

Mark Probst found and squashed one of the hardest bugs in our upcoming garbage collector. Pablo from Codice has been testing the new GC under stress and posted a nice message to the list.

Plenty of great feedback on deprecating old libraries and tools from Mono. We will have a lighter distribution. As things are coming together so fast and we are now well into the features we had planned for 3.0, we might end up just calling the next version 3.0 instead o 2.8.

Andreia got Moonlight running on Chrome.

Jonathan Pobst: Delayed Transition

Jonathan_x0020_Pobst@monologue.go-mono.com — Thu, 04 Mar 2010 00:21:00 GMT

After Comcast's year-long advertising blitz on how their customers were safe from the analog->digital TV transition, I got a nice letter in the mail today informing me that Comcast is going, *gasp*, all digital. All I need to be ready for the transition is a digital converter box for every television, which they will gladly rent me!

Maybe the government will offer vouchers for them. ;)

Mario Carrion: Accessibility in Moonlight

Mario_x0020_Carrion@monologue.go-mono.com — Wed, 03 Mar 2010 18:02:27 GMT

An important milestone happened on Friday, February 26: Mono Accessibility 2.0 was released. It’s important because all applications running on Moonlight 2.0, or greater, will be accessible from now on. Accessibility? If you are not familiar with this word, Accessibility, it might mean nothing to you and, probably, you will need a more formal definition: “Accessibility is a [...]

Gabriel Burt: Banshee Metrics

Gabriel_x0020_Burt@monologue.go-mono.com — Wed, 03 Mar 2010 10:18:00 GMT

Last Wednesday we released Banshee 1.5.4, which included an opt-in feature to submit anonymous usage data. Over 500 people have already opted-in!

Interesting Stats
They are primarily getting Banshee through the Ubuntu PPA, with a moderate number building from source or using other distributions — including 20 OS X users.

383	Ubuntu
33	source-tarball
27	openSUSE/SLED
22	git-checkout
20	OS X
16	Gentoo

They are using Banshee in 36 locales, across 30 languages. Keep in mind the Preference to opt-in is (so far) only translated into 9 languages.

223	en-US
51	en-GB
41	de-DE
35	unknown
21	ru-RU
18	it-IT
14	fr-FR
12	en-CA
11	en-AU
11	es-ES
9	pl-PL
8	pt-BR
6	es-CL
5	es-MX
5	nl-NL
5	sv-SE

About half have the Banshee window maximized, enable ReplayGain support, show the bottom-left cover art, and show the context pane.

I'm still working on better ways to analyze the data and extract actionable information. I plan to have distribution graphs and such soon. In the meantime, I've posted some more stats here. As we get more submissions, add more data points, and get better analysis, we will be able to identify options nobody uses and optimize Banshee for real-world users.

Ivan Zlatev: IBM

Ivan_x0020_Zlatev@monologue.go-mono.com — Tue, 02 Mar 2010 23:05:26 GMT

I started at IBM UK (Hursley Labs) on Monday but it is only today that I got my permanent badge with all the security clearance added for the ultra confidential work I will be doing. One of the goodies when working in the restricted area is that only the chosen ones get access to the proper coffee machine which makes excellent espresso coffee only 10p each.

IBM

Joe Audette: Some New Training Videos

Joe_x0020_Audette@monologue.go-mono.com — Tue, 02 Mar 2010 17:25:37 GMT

Just a quick post to let people know about new training videos available. I am making it my focus for this month to produce a lot more tutorials to answer common questions and especially to help developers get started with custom development. I still have a ways to go with the developer tutorials, but thought I would go ahead an post links to videos I've completed so far.

Installation and Configuration

Developer Series

I've begun a series of clips where I plan to implement a simple Guestbook feature as a way to cover important concepts.

Just getting started so far, lots more clips to produce to complete the Guestbook tutorial. I'm planning to cover development of business and data access classes and how to add supporting pages to your feature as well as how to make your feature searchable. I'm working only from an outline not a script, so the videos are mostly improvised and I stumble on a few things here and there, but rather than edit them out, I think it is helpful since you may also stumble a little bit, so learning to work through the stumbles is part of the process.

Each clip will be less than 10 minutes in order to fit them on YouTube, but they are in high definition so the video quality should be pretty decent.

UPDATE 2010-03-08 -added items 8 - 17 to the list above.

Joe Audette ...

Aaron Bockover: Lemon Shallot Vinaigrette

Aaron_x0020_Bockover@monologue.go-mono.com — Mon, 01 Mar 2010 17:20:48 GMT

Feeling like an arugula salad today, I needed to also use up two shallots before they went bad, so I concocted this delicious lemon shallot vinaigrette. As the arugula is gone, I may finish the dressing with some fish tonight.

I rarely measure anything in the kitchen, so all values are approximate.

Ingredients:

2 shallots
1 cup + 2 tbsp olive oil
1 cup chopped fresh parsley
2/3 cup balsamic vinegar
1/2 large lemon
1/4 cup freshly grated parmesan cheese
1 tsp salt
1 tbsp freshly cracked pepper

Method:

Finely dice the two shallots, saut� over medium heat in the two tablespoons of olive oil until slightly browned and translucent.
Finely chop the parsley for easier blending.
Juice half the lemon, and gather about a teaspoon of zest.
Combine all ingredients into a food processor and emulsify.
Chill and serve.

Enjoy!

J�r�mie Laval: Working on Mono with git-svn

J�r�mie_x0020_Laval@monologue.go-mono.com — Mon, 01 Mar 2010 16:23:01 GMT

CC by-nd by W. T. L.

I won’t go here in depth on how to use git, the official hub has already tutorials to get you started. I’m more interested here in the workflow you can apply and the tools you can use when working on Mono with git-svn (although it can be mostly used in a general way too).

Note: this post is heavily based on the materials written by the accessibility team.

Note�: Prior of everything, your should first read this guide which explains how to setup your git-svn local copy using an existing git mirror. At this point, I expect that you have successfully completed that step.

Mirroring your work

The workflow I will describe here is rather destructive as you are going to end up merging some bits of git history when sending your commit to Subversion. As such, I strongly advise that you have another git mirror of your work somewhere to act as a backup with all your history.

You could either go public with your own server/repo.or.cz/github/gitorious/whatever or simply use a local copy situated e.g. on another drive.

In any case, this repository is not really meant for public consumption (i.e. people directly working on your git tree) as it’s going to be quite unstable with frequent history breaks.

When you are decided on where you want to host your mirror, add a remote to its location with the git remote command :

git remote add name foo@yourdomain.org:mcs.git

When you want to update your remote copy, just issue git push with the remote name and mirror option :

git push --mirror name

Synchronizing�with trunk

The first thing to know is actually how to pull Subversion revisions back into your local repository. As with any command that have to deal with Subversion, the common prefix to use is git svn. This action must be done on the master branch so if you are on another one, switch back to master before doing anything else with git checkout.

Here, the command we are interested in is git svn rebase. This command will actually fetch the revisions from trunk, convert them to git commits and replay your local changes (if any) on top of them :

git svn rebase

Making changes

The equivalent of trunk in git is the master branch. This branch should remain clean of any change and should only be used when you are ready to commit your work to Subversion.

In git, branches are everywhere and are the most straightforward way to organize your changes hierarchically. As such, anything you plan to do should be separated in its own branch with a name like feature-xyz. You can also have feature branch that depends on another feature branch, I will talk about these one later and especially how to merge them back.

The command :

git checkout -b feature-xyz

Will switch you to a new branch where you can happily do your stuff.

What works well here is to follow the scheme : code a piece ?�commit ?�test ?�fix ?�commit. It will especially helps when you have to crawl back through your history at a later point with, for instance, git bissect.

Notice that commit message style at this point don’t matter, use the style that suit you the best because you are the only one who will read them.

During the lifetime of your development branch, it’s likely that some change introduced in Subversion will conflict with what you have done. As such, it’s always a good idea to frequently sync your local copy with Subversion (see above) and then rebase your development branches on top of master.

The�git rebase command exactly serves that purpose and allows to rewrite partially or totally the history of a branch. In practise, this is as simple as issuing from the development branch :

git rebase master

As you see, git rebase is powerful tool but it’s also a destructive one in the sense that it rewrite your history. Rewriting history is the sort of thing that make git crazy when you are trying to pull from a repository modified that way. This is why your git backup should be considered unstable and why you have to always use a mirror or a force option with git push.

Merging work and sending it to Subversion

Let’s say your are happy with what you did, now you would like to send all that stuff to Subversion. Normally, your branch should be filled with small commits with message mainly consisting of « Ooops », « Added part foo » �or « Debugging » which you definitely don’t want to see in the Subversion commit.

That’s why we are going to do a clean summary of the change you made, update the ChangeLogs accordingly and then use a pretty automagically generated log message for the Subversion commit.

First of all, switch back to master branch. Then issue the following command :

git merge --squash feature-xyz

What this do is that it takes the most recent version of the branch tree, generate a diff and then apply it to your master tree without committing. If you check with git status, you will see that these change are notified as « Going to be committed ».

That’s when we use our first tool : clng.py.

I suggest making an alias to it or putting it in a PATH directory to be able to invoke it directly from the command line.

As you can notice, the script expects some environment variable to be set. EDITOR tells which editor you want to use to edit ChangeLog (e.g. emacs), CHANGE_LOG_NAME contains the name that should be used in the ChangeLog (e.g. John Doe) and, finally, CHANGE_LOG_EMAIL_ADDRESS contains an email address that will be put in the ChangeLog next to your name (e.g. john.doe@foobar.com).

When you have set up those environment variable properly, then from the root of the repository (i.e. where the .git directory is), just call the script with no parameter which will prompt you to edit the ChangeLog corresponding to the files you have changed. That time, use a meaningful entry.

When all ChangeLog have been edited, you still have the option to fine tune them (if you made a typo for instance). When you are finished, call the following command to validate the ChangeLogs :

git add -u

Here now comes the second script, clm.py, that will gather and pretty print what you added to each ChangeLog. It uses the same environment variables than previously.

Then, simply type git commit and copy&paste the commit message given by the script.

The two last steps are, first, to run again git svn rebase to make sure that no change got in between while we were doing the merge and, finally, launch the dcommit command to issue your commit to Subversion :

git svn dcommit

Damn, I stumbled upon a bug

It’s quite usual that during development time, you will notice several bugs in the code that is already on Subversion.�Of course you would like to commit the fix right away because it’s an easy enough one. Only problem is that you are, most of time, stuck in the middle of something else with several changes in your working tree that haven’t been committed yet !

Enter git stash. This command will create a temporary branch were all your current changes are committed and then clean your working tree. That way you can painlessly switch back to your bug fixing branch, make some commits to solve the problem, and then push the fix to trunk with the same procedure as described above.

Now, it would be nice if what you were doing before take advantage of that fix (maybe it’s even a prerequisite). Good news is that you can use the same trick as in the sync section with git rebase to make your branch starts from the commit you just created.

Working with a Subversion branch

When you commit a fix, you probably want it to also live in the current stable branch of your software (Mono in our case). That require two things. First, you have to tell git-svn where the branch live and, second, you have to backport the fix.

Normally when you clone the repository in the guide above, you also get all the remote branches with it. If that’s the case then all is good and you can work from that point. If you don’t have the remote branch you are interested in, two options. Either you use git fetch to retrieve all the missing symbols (can take a good deal of time) or you directly put in the config the path of the branch you are interested in. Here is for instance the section to setup your Mono 2.6 branch :

[svn-remote "mono-2.6"]

url = svn+ssh://jlaval@mono-cvs.ximian.com/source

fetch = branches/mono-2-6/mcs:refs/remotes/git-svn/mono-2-6

[svn-remote "mono-2.6"]
��url = svn+ssh://foo@mono-cvs.ximian.com/source
��fetch = branches/mono-2-6/mcs:refs/remotes/git-svn/mono-2-6

[branch "mono-2.6"]
  remote = .
  merge = refs/remotes/git-svn/mono-2-6

The only step remaining is to duplicate the change you made to trunk to this maintenance branch which can be easily achieved with the git cherry-pick command. After the (eventual) conflicts are resolved, just issue git svn dcommit to validate this change.

Merging branch of branch

Sometimes, it happens that you are developing two things at the same time and that one of it is based on the second which translate by the fact that one of the branch depends on the other branch.

In that case, you are certainly going to end up committing the first branch first, continue a bit polishing the second one and ultimately commit it too. Problem is that, when the first branch get committed, the second one should in turn follows trunk/master happening.

Fortunately, git rebase comes again to the rescue with the onto switch. Simply merge and commit the first branch as described in the section above and then, from the second development branch, issue :

git rebase --onto master

It will move your second branch to depend on master which should happen flawlessly since the first changes are now mainline.

Conclusion

This post is of course far from exhaustive and if you have any more tip, share it in the comments.

C�dice Software: Setting up an Oracle backend for Plastic SCM

C�dice_x0020_Software@monologue.go-mono.com — Mon, 01 Mar 2010 12:23:00 GMT

As I mentioned on the Plastic SCM 2.9 announcement, now Plastic supports a new backend: Oracle.
Plastic SCM stores all data and metadata on standard database backends, which is great for data integrity and also to allow you running custom reports by simply running standard SQL queries (something you couldn?t obviously do if we were using some cumbersome ad-hoc file based storage).
So far we do support SQL Server (check how to configure it here), MySql (check here for the instructions on how to set it up) and Firebird (which the one included by default).
When you install a Plastic SCM server on both Windows and Linux it will use a Firebird backend by default. On Windows it will use an embedded Firebird instance (which means there won?t be a separate database server process but it will be run by the Plastic process itself) and on Linux it will use a normal Firebird server.
What I?m going to setup here is the following scenario: Plastic server will work with a separate Oracle server (configured on a different machine) as the following graphic shows:

Of course we could run the Plastic server on the same machine where the Oracle server is installed, but this will give us extra CPU power since we?ll be using two servers instead of one! :-)
Let?s check how to do it:

Stop the Plastic server

Edit/create a db.conf file on the server directory with the right Oracle connection instructions

Check the server can connect against the Oracle instance

Check the client can see the new databases

Stop the Plastic server
If you?re on Windows this is a trivial step: just go to services and stop Plastic SCM.
If you?re on Linux it?s not hard either: su to root and go to the Plastic SCM server installation directory (typically /opt/PlasticSCM/server) and run:


$ su root
# cd /opt/PlasticSCM/server
# ./plasticsd stop

Edit db.conf
If you?re on Linux you?ll have a db.conf file at the server?s directory (/opt/PlasticSCM/server/db.conf). You?ll just have to edit it.
In case you?re on Windows, by default, the file won?t be there, so just create a new one.
Let?s check the contents you?ll have to put for the Oracle connection:

Note: remember ConnectionString and AdminConnectionString must go on one line, it has been splitted here for the sake of clarity.


<DbConfig>
    <ProviderName>oracle</ProviderName>
    <ConnectionString>Direct=true;User={0};Password={0};
       Data Source=oracle.codicefactory.com;
       Port=1521;SID=orcl
    </ConnectionString>

    <AdminConnectionString>Direct=true;User Id=SYS;
       Password=oracle;Data Source=oracle.codicefactory.com;
       SID=orcl;Connect Mode=sysdba
    </AdminConnectionString>

    <DatabaseCreationCommands>
        create smallfile tablespace @PlasticDatabase datafile 
          '@PlasticDatabase.dbf' size 10M reuse autoextend on next 10M;
        create user @PlasticDatabase identified by @PlasticDatabase 
           default tablespace @PlasticDatabase 
           temporary tablespace Temp account
           unlock quota unlimited on @PlasticDatabase;
        grant connect, resource, create session, 
           create table, create view, create any index
           to @PlasticDatabase;
    </DatabaseCreationCommands>
</DbConfig>

First of all you?ve to specify the kind of backend you?re going to use: that?s the line ?ProviderName? and we specify oracle.
Second you?ve two connection strings: one for the ?regular operations? and one for the ?administrative ones?. What does it mean? Plastic will always connect to Oracle using the first connection string except when it has to create new repositories (for instance during the first start up with the new backend) when it will use the AdminConnectionString.

Why we do this? Because if you?re using an Oracle backend chances are you?re setting it up on a corporate server, which means your IT department will have tight control on it, and they won?t probably like the idea of having an application running with high permissions continuously. So this way we clearly separate the way in which connections are established, which will make your IT team happy.

Then we?ve the DatabaseCreationCommands which lets you customize the way in which databases are created.

By default every Plastic repository will be a tablespace, and we?ll create a user associated to it. You can find the create tablespace and create user sentences there and you can modify them to better adjust to what you really want to achieve.
For instance, the tablespace is created as an small one, but probably you want to create it as a bigfile and also adjust the initial size to something bigger than 10Mb and autoextend with a larger amount too.

Check the server can start with the new configuration parameters
Once you?ve edited db.conf the next step is to start up the Plastic server again and check everything is up and running.
While you can directly use the plasticsd script to restart your daemon on Linux or go to services and start the service again (and it will work if you set up everything correctly) I?m going to show you a small trick which is very useful for diagnostics: just run


plasticd --console

And the server will start in console mode. Wait until you read a message telling the server is up and running on check the errors if any.
In case you need detailed information, check the loader.log.txt file which will contain the errors.

Note: something very useful for diagnostics is modifying your logger configuration (loader.log.conf) to make plasticd output the log on the console, and then rapidly check if something is wrong. Remember to set it back to file logging once you?re done!

Once you?ve checked you can start up the service/daemon, you can run it with the regular services or ./plasticsd method.

Check you can connect to the new database

If you run a cm lrep command against your server now you should see your new empty databases being created. You must be able to create new repositories too.

Screencast
The following screencast we?ve just uploaded to our YouTube channel shows how to set up an Oracle backend on a Linux Plastic server. Check it to see the steps I just have described in action.

Jordi Mas: gbrainy 1.40

Jordi_x0020_Mas@monologue.go-mono.com — Sun, 28 Feb 2010 20:26:00 GMT

Here we have gbrainy 1.40, two months after the previous major version. gbrainy is a game that challenges your logic, verbal, calculation and memory abilities.

What is new in version 1.40 from the NEWS file:

Version 1.4
* 2 new logic games
* Deprecated Glade and moved to Builder
* Mouse support
* Better RTL support
* Updated and new translations (Hungarian, Afrikaans and Finnish)
* Remove dead and legacy code
* 12 Bug fixes

gbrainy 1.40 is available for download in source code from:

* http://gent.softcatala.org/jmas/gbrainy/gbrainy-1.40.tar.gz
(md5sum fe7b25b08c2004d887f9fd092fba962f)

Additionally, gbrainy is available for all major Linux distributions.

gbrainy short term plans

There a few bugs still pending to be fixed from Bugzilla, and some additional ones coming from the Ubuntu community and others from personal e-mails. I'm planning to release a gbrainy 1.41 in 4/6 weeks. This minor release will contain fixes for these issues plus all the updated and new translations. After this, I will start to work on the next major version.

How to help

This is a common question that I get. Let me point out some areas where you can help:

Play the game and provide feedback about the application.
Translation to different languages. Check the current status of gbrainy translations.
Any development aid, including fixes or new Puzzles for the current system (see the development section)
Ideas for new logic puzzles, memory, calculation trainers or verbal analogies.

If you like gbrainy, blog about it and tell your friends!

Thanks to everyone that has given help or feedback to this version: Siegfried-Angel Gevatter, Sam Tygier, Robert Ancell and also to all the translators.

C�dice Software: Announcing Plastic SCM 2.9

C�dice_x0020_Software@monologue.go-mono.com — Sun, 28 Feb 2010 12:12:00 GMT

Plastic SCM turns 2.9 and it?s ready to download from our site: www.plasticscm.com.

It comes with a bunch of new features and also gets faster specially under heavy load.
Here are some of the new things we?ve included:

Oracle support: yes! We?ve added Oracle to the list of our supported database backends. It joins the group integrated by MySql, SqlServer and Firebird. Oracle has been requested several times by corporate users and it brings one of the strongest RDMBs on the market to Plastic deployments. Performance, stability and scalability are the main goals for it, and it works with Windows, Mac OS X and Linux servers.

Pulse continuous integration is now supported: we built a plug-in for Zububi?s continuous integration product. It expands the number of supported build solutions we have, together with CruiseControl and FinalBuilder, although others like Hudson (and any product out there being able to run a couple of ?cm? commands) can work with Plastic too.

Proxy server: now it?s possible to set up cache servers to reduce network usage while connected to a central server. The proxy simply caches data on demand and avoid re-downloading it again, saving precious network seconds. Note: you know Plastic can work on both distributed and centralized modes, so obviously this feature is useful for people connecting to remote servers and not that much for distributed developers or teams since they already have their data quite close.

Sparse tree and cloaking support: now it is possible to download only parts of a repository (ok, it was also doable with selectors, but this way is probably easier) and avoid updating certain files or entire trees by using a cloaked.conf file specifying rules to cloak elements. It?s very useful specially to speed up certain operations (like update) on huge trees and hence avoiding walking through certain parts you know you?re not interested on receiving changes. For advanced users only.

Replication memory footprint has been greatly reduced. Memory usage during replication has been reduced, making it faster and much more predictable than before. Now you can replicate an entire repository and the server won?t even notice it in terms of memory footprint!

Workspace server is gone! Yes, as you read it, we?ve removed the workspace server component from the picture. Well, in fact, what we?ve done is move it into the client, so performance is dramatically increased. What does it mean? Watch your newly created workspaces and you?ll see a new directory (hidden) named .plastic, it contains workspace information like the selector and the tree with the information about your working copy. This information used to live on the server side, but it has been moved to the client. It dramatically speeds up the system on many scenarios and reduces network usage, which was probably not noticeable on LANs but makes a huge difference for users working against a central server using a VPN. Important note: when you upgrade from Plastic 2.8 to 2.9 the system will recalculate your workspaces in order to move to the new format. It will only happen once and it will be pretty fast (your workspace content won?t be modified, it?s all just about metadata). If you?re using the graphical client you?ll see something like the following:

Sharable workspaces: with the modifications made on the workspace it?s now possible to share workspaces: you can place a workspace on a shared network drive or a NFS directory and more than one user can access to it, update it and so on from different machines. Previously it was not doable with Plastic unless you registered the workspace on several locations, and even then it could end up with race conditions. It has been solved. Use it with care, I mean, sharing a workspace can be good for release building purposes but obviously the whole point of having a SCM is being able to manage your own private working copy!

Changeset walking: one of my favorites! You can walk branches changeset by changeset, reading the story they?ve to tell. I?ll post more about it later but think about it: on your own feature branch you?re free to do as many commits as you won?t before hitting the mainline, but it doesn?t prevent you to self document your changes by committing often and with meaningful comments and changes. Let me elaborate a little bit more: suppose you?ve to do a big refactor, you make a whole bunch of changes, then if you review the whole thing at the end, it will be hard to follow, but if you describe every individual modification (considering it as a logical change, potentially involving several files) in a commit, this tool will let you review what you?ve done later, very, very easily.

Branch explorer enhancements: new search functionality landing on branch explorer, together with active information about merge links (click on one and it will tell you where it is coming from) and the long awaited visibility editor.

Well, and that?s basically it, together with a huge number of small tweaks here and there. We run load tests weekly on a 100 nodes cluster, and under really heavy load Plastic 2.9 is about 30% faster than its predecessor. Not bad! Remember we were already 10 times faster than SVN with 2.8 and make the math.

And the best thing: Plastic grows but stays easy to use and easy to install. Take a look at the following screencast: I install a Plastic server in less than 45 seconds!! And I make an initial code import after that (the first steps you?d probably do during an evaluation) during the next minute. Easy! Take a look at the latest TFS 2010 and tell me if you can set up the whole slow monster in 45 seconds!! :)

Enjoy.

C.J. Adams-Collier: Connecting to MySQL with ODBC on Mono

C.J._x0020_Adams-Collier@monologue.go-mono.com — Fri, 26 Feb 2010 22:26:44 GMT

We had a visitor on #mono today who needed help with his homework. It seems that Reggie is happy to have forgotten everything about using ODBC to connect to MySQL. I was curious and feeling helpful, so I figured it out.

Install the MySQL ODBC driver

$ sudo apt-get install libmyodbc

You can also grab the package directly from MySQL

Configure the MySQL ODBC driver

ODBC looks in /etc/odbcinst.ini for driver configuration. In order to let it know about the MySQL ODBC libraries, append the following to your /etc/odbcinst.ini file:

[MySQL]
Description	= MySQL driver
Driver	= /usr/lib/odbc/libmyodbc.so
Setup		= /usr/lib/odbc/libodbcmyS.so
CPTimeout	=
CPReuse	=

Configure your DSN

If you expect that you will be using this database connection often, you may want to create a short name for it, so you don’t have to enter all of the parameters every time you want to connect. ODBC uses something called DSNs (Data Source Names, if I recall correctly) to make it easier on the user.

If you want to create a DSN, append something like the following to your /etc/odbc.ini file:

[myodbc3]
Driver       = MySQL
Description  = MySQL ODBC 3.51 Driver DSN
Server       = mysql
Port         =
User         = testuser
Password     = password
Database     = test
Option       = 3
Socket       =

You will also need to update the ODBC Data Sources list near the top of the file to mention the new DSN:

[ODBC Data Sources]
myodbc3     = MySQL ODBC 3.51 Driver DSN

C? ODBC connection example

Here is some example code to get you connected:

using System;
using System.Data;
using System.Data.Odbc;

class ODBCTest {
  public static void Main(String[] args) {
    // Connection string using explicit parameters
    string ConStr = String.Format(
      "DRIVER={0};SERVER={1};DATABASE={2};UID={3};PWD={4}",
      "{MySQL}","mysql","test","testuser","password" );

    // Connection string using DSN
//  string ConStr = String.Format("DRIVER={0};DSN={1}",
//                                "{MySQL}","myodbc3");                       

    //Create the connection object
    var OdbcCon = new OdbcConnection( ConStr );

    try {
      Console.Write("Opening connection... ");

      //open the database connection
      if (OdbcCon.State == ConnectionState.Closed)
        OdbcCon.Open();

      Console.WriteLine("connection opened!");
    } catch (OdbcException Ex) {
      Console.WriteLine(Ex.Message);
    } finally {
      //close the database connection
      OdbcCon.Close();
    }
  }
}

Brad Taylor: Mono Accessibility 2.0 unleashed!

Brad_x0020_Taylor@monologue.go-mono.com — Fri, 26 Feb 2010 20:37:09 GMT

Today, I'm proud to announce the 2.0 release of the Mono Accessibility project. Spanning a year of intensive work and fixing over 500 bugs, this is truly our best release ever.

This release enables all types of users to access System.Windows.Forms and Silverlight applications from Linux using Orca and other ATK-based Assistive Technologies (ATs), as well as access Linux applications from UI Automation (UIA) based ATs.

What's changed since version 1.0?

Added:

UI Automation provider support for Moonlight
UI Automation to ATK bridge for Moonlight to allow Moonlight applications to be accessed by Linux ATs
Complete implementation of the UI Automation Client API, facilitating access to System.Windows.Forms, ATK-based applications and Silverlight controls for UI Automation Clients.

What is Mono Accessibility:

The Mono Accessibility project enables Winforms and Silverlight applications to be fully accessible on Linux, and allows Assistive Technologies (ATs) like screen readers and test automation tools that depend on UI Automation APIs to work on Linux.

Mono Accessibility is released under the MIT/X11 license.

Get it!

Mono Accessibility is available for a variety of Linux distributions, including:

openSUSE 11.2 - 1-Click Install
Ubuntu Karmic Koala - Package Archive on Launchpad
Fedora 12 - Repository on openSUSE Build Service
Other distributions - Source tarballs

A Note About at-spi2

Accessing GTK+ applications with the UIA Client API requires the most recent development version of the new dbus-based at-spi2, which is known to cause system instability.

In Fedora, at-spi2 repeatedly causes GDM to segfault. If you do not need this feature, do not install the latest at-spi2 and atk, or our packages which depend on them, which are at-spi-sharp and AtspiUiaSource.

We are working hard to identify these issues and hope to aid the GNOME Accessibility Team in stabilizing at-spi2 in the near future.

Find out more

Navigate to our homepage for all the latest information, and ways to contact us.

Marc Christensen: SLLUG meeting Feb. 24, 2010: Introduction to Mono

Marc_x0020_Christensen@monologue.go-mono.com — Wed, 24 Feb 2010 22:12:21 GMT

Tonight’s Salt Lake Linux Users Group meeting will be an introduction to Mono. See the mono-project for more information.

“Mono is a software platform designed to allow developers to easily create cross platform applications. Sponsored by Novell, Mono is an open source implementation of Microsoft’s .NET Framework based on the ECMA standards for C# and the [...]

Gabriel Burt: Banshee 1.5.4

Gabriel_x0020_Burt@monologue.go-mono.com — Wed, 24 Feb 2010 17:12:00 GMT

Banshee 1.5.4 is out, with cool new features and lots of fixes! This is our fifth release in preparation for our big 1.6 release at the end of March.

Banshee Community Extensions

We have made a 1.5.4 release of Banshee Community Extensions as well. This includes the Alarm Clock, Lyrics, and Mirage extensions, and several others.

Mirage Similarity Engine

The Mirage extension has been modified heavily, dropping the old ?Automatic Playlist Generator? in favor in integration into the playback controller – adding shuffle-by-similar, and into the Play Queue Auto DJ – adding fill-by-similar. Mirage calculates the acoustical similarity between two songs.

Play Queue Auto DJ, fill by similar

Anonymous, Opt-in Usage Data

Under Preferences, you can choose to "Improve Banshee by sending anonymous usage data" back to the Banshee developers. This collects information on what version you're running, what OS, library size, slow SQL queries, and a whitelisted subset of your preferences. This information will help us choose better defaults and see what parts of Banshee are used most and can be improved.

The 30+ people running a development version of Banshee and already submitting data are using 11 different language locales, have a median screen resolution of 1440x1024, and a median music library size of 5k songs. I'm working on some analysis/viz software to crunch the data - stay tuned!

Other Notable Improvements

Wikipedia context pane extension enabled by default
Add support for Nokia N900 phones
Coverart for unicode artist/albums now supported
Dropped glade-sharp dep; GNOME 3.0 ready
Add columns showing track sample rate and bits per sample
Option to sort an artist's albums by year, not title
Fixes to GIO backend
Many crash/startup fixes for OS X build
Fix several memory leaks

More Information

As always, check the release notes for more detailed information, screenshots, and download links. Thanks to everybody who made this release happen!

Lluis S�nchez : Loading executables as MonoDevelop projects

Lluis_x0020_S�nchez_x0020_@monologue.go-mono.com — Wed, 24 Feb 2010 16:11:00 GMT

Miguel recently blogged about a trick for loading an executable assembly as a project inside MonoDevelop. I have now added native support for this feature, which means that it is now possible to directly open a .exe or .dll as a project, or add it to an existing solution. Also, MonoDevelop will get the list of source code files from the debug info of the assembly (when available). For example, this is what you get when you open gmcs.exe:

The code just landed in SVN.