MonoDevelop: The .NET Developer’s Linux Outlet

4
Oct
2007

I’ve done my fair share of .NET development. I’ve never actually enjoyed it, nor would I want to make a living out of it, but I have done some. Every time, I’ve been forced to work on Windows to do any serious project. Granted, jEdit can get you awfully far in terms of source editing, but unfortunately (?) it’s no IDE. Really, the only way to do serious .NET development is to use VisualStudio.

Now, for a number of reasons (none of which are important right now), I’m already using Windows as my primary OS. However, I don’t like being boxed into one OS or another. I try to keep my options open. If I ever could cut those final ties to Windows, I’d love to switch to Linux or Mac. Also, I just don’t like feeling forced to do something in a certain way. With Java, I can write the code in Eclipse, NetBeans, jEdit or Notepad for all my employer cares, just as long as it gets done. With .NET, I really don’t have any choice but to use Windows.

Well, until nowish. MonoDevelop recently announced the release of 1.0 beta 1. From what I’ve read, things are still comparatively unstable, but the features are all there and bug fixing is proceeding apace. Also, for the first time it seems that they’re offering some binary packages, allowing users to install easily rather than wrestling with the sources for hours and hours (which is what happened to me last time I tried MonoDevelop).

Actually, the bigger news for me is the addition of all of the “serious coding” features. Things like content assist, searching, error-underlining, etc. These are huge when working on a non-trivial project. In fact, these are precisely the reason I tied myself to Windows and VisualStudio for .NET development rather than just using jEdit or VIM on Linux. Last time I tried MonoDevelop (back in like, 0.2), it really wasn’t more than a glorified text editor with syntax highlighting. Now, it’s a full-fledged IDE.

As far as I’m concerned, MonoDevelop has reached the point where it can be considered as a serious VisualStudio on Linux. In fact, from what I’ve seen it’s at a level where .NET developers need no longer consider themselves tied to Windows just for the tools.

Of course, the big problem is MonoDevelop is a tool to write code that runs in Mono (hence the name), not really .NET. Technically, the two platforms are very very close, but .NET has some libraries and provides certain functionality that Mono just doesn’t emulate yet (things like the win32 API). Also, Mono is a black-box port, so there are bound to be some inconsistencies in behavior here and there. As a result, you can probably write your .NET application on Linux using Mono, but you had better test it running on Windows and the CLR. Otherwise you can never really be sure that your app is doing what you want it to on Windows.

But on the whole, I think this is great news! MonoDevelop gives .NET developers a nice (and free) alternative to VisualStudio, not to mention the benefit of unfettering these developers from the Windows platform. Just one more way to thumb your nose at the boys in Redmond and support FOSS.

Update: The How-To Geek has some excellent instructions on how to install the latest version of MonoDevelop on Ubuntu.

Filed in .NET | Comments (2)

SaveableEntity Bids a Fond Farewell

15
Aug
2007

Well, to make a small, side entry out of something which probably should be in bold print on the ActiveObjects website… It’s worth announcing that I’ve merged SaveableEntity into the Entity super-interface. The only reason to keep these two separate was so that some entities could be configured to receive calls to setters and immediately execute UPDATE statements. This is a really inefficient way to code your database model and I think the only real use of it was in my sample code. :-) Since it really was an API misstep, I’ve decided to do away with it. The save() method is now obligatory for any data modification. Thus, any legacy code you may have which extended Entity may not function in the way you would expect (e.g. the DogfoodBlog example no longer persists data properly). If you have any code which extended SaveableEntity, just change this to extend the Entity interface and everything should work as before. Just thought I’d make a general announcement.

Filed in Java | Comments (4)

Fuse 0.4 Release

2
Jun
2007

Some of you may know that I worked (and have been working) on a little open source project with Romain Guy called Fuse, hosted under SwingLabs at java.net. (not related to the Filesystem in Userspace project) It’s a pretty neat project that was actually started by Romain to assist in the development of the Aerith demo (shown at JavaOne 2006).

The whole idea behind the project is to provide a simple, easy to use resource injection library. Resource injection is different than dependency injection for a number of reasons (explained in more detail on the project page), but suffice it to say that this is an incredibly useful little library that makes centralizing your resource configuration a piece of cake.

I started using Fuse on a regular basis at about the same time I stopped developing Fuse on a regular basis. After I started my latest contract work (back in early last July), I no longer had enough time to devote to the project, so it went by the wayside almost immediately after the 0.3 release. Romain too, was working on various projects (including the book Filthy Rich Clients, coauthored with Chet Haase), so the project really would have just lain dormant for a while, except that I was actually using Fuse in the project I was working on.

This was really the first time (that I know of) that Fuse was used in a solid, large scale application. Those of you that have developed experimental libraries in the past know that you don’t really know that an API is working the way you want until it’s tested in a bona fide application. Well, that was true with Fuse too. In the process of using Fuse, I was able to isolate and fix a number of pesky little bugs that had slipped through our unit testing, as well as improve performance immensely.

Most of the changes made to Fuse were bugfixes, but the big ticket new feature is transparent caching of loaded resources. If a resource has the same value and type as one which has already been instantiated and injected, that instantiated instance will be used. Since Fuse is designed for (though hardly limited to) the injection of immutable resources, this works out really really well. I’ve noticed a huge return in performance from this simple change (alla GUI load times 2x as fast).

Most of these changes (including caching) were made gradually over the last 10 months, so there wasn’t really a clear line where we could say “this constitutes a release now.” For my project, I was just using a custom build of the CVS HEAD version of Fuse, rather than the 0.3 “stable” release. Ironically, it had gotten to the point where I was actually telling other people to use the HEAD version since I knew that it would be more stable and performant than the 0.3 release.

Eventually (as in yesterday), Romain and I decided that there was no real reason to hold off on a release any longer. While our documentation may still be woefully out of date, and while neither of us remembered enough changes for an impressive RELEASE NOTES, we still think that pushing out 0.4 was the right choice.

So, the 0.4 release is now up on the java.net servers and available for download here. If you’re interested in Fuse, or if you’re using Fuse already (especially if you’re using Fuse already), I suggest that you run over to the download site and grab the latest version. There were no API changes in this release, so it should just be a drop-in replacement for the 0.3 version you’re using now.

Oh, if you’re interested in Fuse, there’s some very good explanatory documentation on the project page. It’s a bit out of date (I don’t think it mentions auto-injection even once), but it does a good job on the concepts and provides a solid starting point for anyone wanting to try the library for themselves.

Filed in Java | Comments (4)

DZone Gets a Facelift

1
Apr
2007

Well, after months of development work, Rick and Matt have finally deployed their DZone site redesign to the production servers. It’s been running on a dev server for a while now, whilst those of us “in the know” tried to break it or offer constructive criticism. However, I think we’re all quite relieved that it’s finally up at dzone.com. So, without further ado, a brief look at the new look!

The first thing you’ll notice is that it’s blue, very blue. The old look was really more of a green and yellow deal with a generous dose of white (everyone’s favorite). The new look has blue borders, blue gradients, blue rollovers, and subtle blue-colored hovers. There are rounded corners galore, high resolution avatars, improved comments LAF and a neat new scrolling feature which I’ll touch on a bit later. Probably the second thing you’ll notice is that your voting options have increased, and your complain option has disappeared. People were overusing the complain feature (especially “just plain lame”), so it was removed and replaced with “down vote”.

This release also sees support for “unvoting”, both up and down. How many times have you clicked on the vote header when you were actually going for the thumbnail? Well, now, you can just unvote your mistake and move on (or more preferably, vote more accurately and more prolifically). This feature was discussed at length amongst the DZone staff, and it was decided that this really was a good idea. There are no restrictions on unvoting yet, but if we see a significant amount of gaming surrounding the feature, steps will be taken…

The scrolling feature is pretty sweet too. To test it out, scroll all the way to the bottom of the front page. After a moment’s hesitation, the next several links will load automatically and populate into your browser (by the power of the mighty AJAX). This works on any link aggregation page (FP, the queue, saved and shared).

I have one more feature to mention before I close this already lengthy writeup: sharing and saving. You can now share links (Google Reader style) easily as you traverse the front page (or more preferably the queue). Shared links go into your profile’s “shared” section, which has its own URL you can send to your friends. It also has its own RSS feed which you can use to more conveniently spread your links to the far corners of the globe.

Saving is a similar feature which allows you to mark a link for inclusion into your “saved” section, which is not a public area. This way, you can mark things as “for later attention” without having to vote, comment, share or otherwise publicly dog-ear the link. I don’t know about you, but I will probably use this feature constantly.

Oh, one important thing to note: everyone should re-upload your avatar. DZone used to only support 16×16 images for your avatar. The new maximum size is 80×80, but there are numerous scaled versions which are saved. If you have a high resolution image for your avatar, upload it asap to get the clearer quality on all your posts.

There’s so much more in this release that I haven’t had a chance to tell you about. Hopefully, one of the other DZone staff (I’m crossing my fingers for Rick) will do a more complete writeup in the near future detailing the new features more thoroughly than I could here. Enjoy the new interface!

P.S. I forgot to mention it. DZone.com now supports OpenID login. It only allows you to vote and comment on links, since OpenID doesn’t actually do anything more than authenticate you. To do anything more (like post or share), you have to upgrade your login to a full DZone username. But still, it’s a cool leap into a burgeoning new technology.

Filed in DZone | Comments (9)