Why GNOME Do Is Built With C#
Language and Architecture Decisions
Paul Ferrill
Thursday, July 16, 2009 12:25:35 PM
With all the recent heat generated about Mono and the C#
language, it only seems appropriate to take a look at the issue from a
programmer's perspective. There are a number of open source projects written in
the C# language. Banshee, F-Spot and Tomboy are three of the most popular.
F-Spot has even made it to the status of default photo management tool for several
distributions including openSUSE and Ubuntu.
GNOME Do is a great
example of open source software that started out as the pet project of one
individual. In actuality, it began as the senior thesis project for David
Siegel. David needed to come up with an idea for a software project that would
embrace the development concepts of the open source community. Having most of
his experience in the Mac world, he decided on building a Quicksilver lookalike
for Linux.
Language Decisions
David had made the initial decision to build his tool for
the GNOME desktop environment on Ubuntu. He looked at a number of different
languages including C, Python, Vala, Java, Boo, Haskell, Clojure, and OCaml.
The decision to use C# came through a process of elimination. Here's how he
answered the language question in response to a post on his
blog:
"I implemented basic Gtk+ examples in most of those
languages (the ones that had Gtk+ bindings in a reasonable state) and found
that C# on Mono gave me a statically typed language, pretty good performance,
tons of support, preexisting applications to learn from, well maintained
documentation, bindings, and libraries, and published books on .NET/C#/Mono."
The Mono group also has a lively IRC channel where you will
Other Stories on LinuxPlanet
|
find many of the principals hanging out and answering questions. "When I first
started coding in C# I ran into a few things that I couldn't figure out. I went
on the Mono IRC channel, and Miguel answered my questions straight away. He
helped me get through a few rough spots, and that alone really impressed me
about the community support for C#," says David.
Architecture Decisions
One of the features that made its way into GNOME Do early on
was the concept of a plugin architecture. Writing plugins can be a difficult
task for some environments. One of the examples that David looked at during the
evaluation process was Catapult for
KDE. The first thing he identified when evaluating Catapult was the difficulty
of building plugins. Everything was built using C++, and the whole process was somewhat
complicated.
Monodevelop is the development environment of choice for
building GNOME Do plugins. The best way to learn how to build a new plugin is
to take an existing one and modify it to meet your own needs. You can find a
large list of existing plugins on the GNOME Do wiki site.
The other big lift from using C# and managed code is the
ability to take user contributed code and just drop it in. For example, the
Skype plugin has between 2000 and 3000 lines of code in it. All plugin code is
kept on the launchpad site. The
team builds the plugins as-is from that site and they are available to GNOME Do users
through a preferences menu. The sandbox runtime environment of
the CLI provide an extra measure of security you can't get with a language like C while
C#'s static typing help take the worry out of runtime errors common to dynamic languages.
The last paragraph was corrected to more fully explain how plugin authoring is managed-- ed. Next: The Big Picture and the Bottom Line »
