This is the archived version of Roland Weigelt's weblog that ran from 2003 to 2023 at weblogs.asp.net

Archives

Archives / 2007

  • EventFilter Helper Class

    3 Comments

    EventFilter is a generic helper class for dealing with events that may be raised multiple times in rapid succession, when only the last event of a “burst” is of interest.

    Introduction

     

    Imagine a Windows Forms program mimicking the GUI of the Windows Explorer, where selecting a folder in the tree view on the left side will update the list of files on the right. A "quick'n dirty" implementation would handle the SelectedNodeChanged event of the TreeView control to update the file list, but a robust implementation that works nicely with slow media like CD/DVD or network drives should use a different approach.

    When playing around with an actual instance of Windows Explorer and watching it more closely, you'll quickly notice that the file list is not updated immediately, but after a slight delay. You can use the keyboard in the tree view to move quickly from folder to folder, skipping folders you are not interested in. Only after you stay on a folder for a little while, the file list gets updated.

    This approach of "wait until things have settled down a bit and then handle the last occurrence of an event" is pretty common in GUI development. The typical implementation uses a timer that is reset each time a new event is raised within a certain time interval, until the timer is finally allowed to elapse. Only at that time the event will actually be handled.

    During development of a small hobby project called RemoteCanvas I got tired of taking care of timers, helper variables and event handlers over and over again, so I finally wrote a helper class acting as a "filter" for events.

    Usage

    • Declare a member variable to hold an instance of the EventFilter class, with an event argument type matching that of the event to be filtered:
      private EventFilter<EventArgs> _filter
          = new EventFilter<EventArgs>();.
    • Hook up the HandleOriginalEvent method to the original event of the control. There's no great design time support for this, so you have to do that manually, e.g.
      myControl.SelectedIndexChanged += _filter.HandleOriginalEvent;
    • Connect the FilteredEventRaised event to your event handler:
      _filter.FilteredEventRaised += MyHandler;
    • That's it!

    Download

    The source code for the helper class (plus a small demo project for Visual Studio 2005) can be downloaded here.

  • GhostDoc 2.1.2 Released

    11 Comments 
    <summary>
    GhostDoc is a free add-in for Visual Studio that automatically generates XML
    documentation comments for C#. Either by using existing documentation inherited
    from base classes or implemented interfaces, or by deducing comments from
    name and type of e.g. methods, properties or parameters.
    </summary>

    20071125_GhostDocQuick Facts

    • Bugfix release
    • Download on the GhostDoc Website
    • Users of earlier versions: Please read the ReadMe on upgrading!

    About this Release

    Version 2.1.2 fixes a problem with side-by-side installations of GhostDoc versions for Visual Studio 2005 and 2008.

    What’s New in GhostDoc 2.1.2:

    • Fixed: GhostDoc versions for Visual Studio 2005 and Visual Studio 2008 interfering when installed side-by-side.
    • Changed: An upgrade installation by starting the MSI file while an older version is installed is no longer supported, i.e. you have to uninstall GhostDoc before running the new setup. Note that this does not affect an upgrade of the configuration of earlier versions: the configuration file is not removed during uninstallation of the GhostDoc add-in, so you'll still be offered to upgrade your configuration when installing the new version. For detailed installation instructions, please take a look at the ReadMe in the ZIP file.
    • Added: A few special words for ("of the" trigger and prefix words, "no the" words).

    Note that VB.Net support is turned off by default and has to be turned on in the configuration dialog.

  • Microsoft TechTalk zu Besuch bei "Bonn-to-Code.Net"

    No Comments

    Am 20.11. findet an Stelle des üblichen User-Treffens der Bonner .NET User Group ein Microsoft TechTalk mit dem Titel “Übersicht zum Expression Studio” in den Räumen der Comma Soft AG statt. Anders als sonst beginnt die Veranstaltung bereits um 18:00, auch ist dieses Mal eine (kostenlose) Anmeldung erforderlich.

    Anmeldung und weitere Infos bei Microsoft, eine ausführliche Beschreibung der Anfahrt gibt es auf der Website von Bonn-to-Code.Net.

    Also: Anmelden nicht vergessen!

  • Is Your IDE Hot or Not?

    5 Comments

    Interesting: Devs posting their font and color settings to a website (http://idehotornot.ning.com).

    Most of the themes are pretty dark, seems like people either have fond memories of their first PC or watched too many Hollywood “hacker” movies (no offense guys, just kidding ;-). Right now reading the tag cloud is like “tag tag tag tag DAAAHAAAAARK!!!! tag tag tag light” (note that due to the dynamic nature of the website this may no longer be the case at the time you’re reading this).

    Long time readers of my blog know that I’m a proponent of proportional width fonts for editing source code, and I like to play around with all the customization features of the IDE (e.g. bold fonts for certain elements). I published the results of my experiments last year a blog post, now I’ve uploaded my settings for Visual Studio 2005 to the “IDE hot or not” website where you can review and rate it.

    Update 2007–07–28: The “IDE hot or not” website has downscaled my original image showing the color scheme down to a point where it’s hard too see anything. So I’ll post the image here:

  • Vortrag über Visual Studio Extensibility in Braunschweig

    1 Comment

    Nach Leipzig bin ich nun am nächsten Montag, 16.7.2007, in Braunschweig bei der dortigen .NET Developer Group zu Gast. Ab 19:00 halte ich einen Vortrag über Visual Studio Extensibility mit den folgenden Themen:

    • Code Snippets
    • Project/Item Templates und Wizards
    • Makros
    • Add-ins

    Ein gewisser Schwerpunkt wird bei den Visual Studio Add-ins liegen, wo ich u.a. auf den einen oder anderen Fallstrick hinweisen werde, über den ich bei der Entwicklung von GhostDoc gestolpert bin.

    Die Teilnahme ist kostenlos und ohne vorherige Anmeldung möglich, die Veranstalter freuen sich aber bestimmt über einen kurzen vorherigen Kontakt. Veranstaltungsort ist das Restaurant Flair.

    Zur offiziellen Ankündigung

  • GhostDoc 2.1.1 Released

    5 Comments 
    <summary>
    GhostDoc is a free add-in for Visual Studio that automatically generates XML
    documentation comments for C#. Either by using existing documentation inherited
    from base classes or implemented interfaces, or by deducing comments from
    name and type of e.g. methods, properties or parameters.
    </summary>

    20070624_GhostDocQuick Facts

    • Bugfix release
    • Download on the GhostDoc Website
    • Users of earlier versions: Please read the ReadMe on upgrading!

    About this Release

    While adding VB.Net support in 2.1.0 I somehow introduced a bug that broke a few things, causing the “Document this” command to not work properly in some situations. In full accordance to Murphy’s Law the bug was hidden in the thin layer between Visual Studio and the main portion of GhostDoc that isn’t covered by unit tests…

    What’s New in GhostDoc 2.1.1:

    • Added: A bit more detailed logging information at certain places. Please take a look at the topic “How to Enable Logging” in the help file for details.
    • Fixed: "Document this" not working on properties defined in interfaces.
    • Fixed: Readonly properties in interfaces not recognized properly in VB.Net.

  • Four Years of Blogging

    No Comments

    Over the last years I have blogged about various things, but a quick look at the tag cloud of my weblog shows that a large number of posts had one specific topic: My hobby project GhostDoc. It’s easy to forget how long GhostDoc has been in the making (with large pauses in between, of course), so for this “blogiversary” I guessed I’d take a look at the history of GhostDoc in the context of this weblog.

    2003–07–02: First Blog post. Just another blogger making his first appearance. Hey, give me some credit, I didn’t use the “Hello World” line…

    2003–11–21: First mention of GhostDoc in a blog post. 3:15 am, a good time to post an announcement of a new project.

    2003–11–28: Release of GhostDoc 0.5 consisting of a macro, a helper assembly and a looong list of installation instructions. The silence in the blogosphere regarding this release is deafening. Sometimes people see a tool, look past the limited scope of the first release and get excited about what that tool could do in the future. Not in this case.

    2004–01–13: Screenshots of GhostDoc 0.9. That version never sees a public release, just a bunch of my colleagues are crazy enough to install it...

    2004–06–30: GhostDoc 1.0 is entered as a contest entry to Roy Osherove’s Visual Studio add-in contest. Just minutes before the end of the deadline, in true geek style.

    2004–08–13: 1st Place for GhostDoc. One of the prizes: A tour of the Microsoft Campus in Redmond – but I have to get there by myself. Did I mention I live in Germany?

    2005–04–15: A GhostDoc Feature I Will Not Implement – this is a classic.

    2005–04–21: I receive a copy of the book (Visual Studio Hacks by James Avery) I wrote a chapter for. It may be only one chapter of many, but mum and dad are very proud.

    2005–09–07: Microsoft Campus Tour. A slight detour to Redmond on the way to PDC 05. I get there by myself (remember?), I get a tour of the campus. What a cool day.

    2005–10–03: GhostDoc 1.3.0. The last version for Visual Studio .NET 2003, and (praise the gods of Extensibility) the last time I have to mess with COM registration of Visual Studio add-ins.

    2005–10–04: GhostDoc on Channel 9 – sort of. No interview, just the video that was shown before at the “Show Off” session at PDC 05. Please don’t ask how much time and effort went into these 4:36. It’s ridiculous. And by the way: yes, that’s a German accent.

    2005–11–11: GhostDoc is one of "10 Must-Have Add-Ins" in MSDN Magazine –sounds good. Depending on the point of view, the fact that the article was written by James Avery (author of Visual Studio Hacks mentioned above) may have helped, but people seem to agree.

    2005–11–15: The results of the Larkware Contest 2005 are in: GhostDoc 1.9.0, the first release for Visual Studio 2005, makes the confusingly named second place (“1st prize” behind a “grand prize”).

    2006–04–01: A Sneak Peek at GhostDoc 2.0. Some people obviously didn’t check the date. The “real” 2.0 is released in May 2007.

    2006–09–21: GhostDoc Wins the Audience Award at BASTA! Conference. Imagine yourself standing on a stage in full stage light, looking at a pretty huge audience. Imagine ten nominated projects to be voted for by show of hands. Imagine your project getting virtually as many hands as the SharpDevelop project (what? wow!). And then imagine a completely different project receiving the prize, causing overall confusion. That’s what happened on that day. And before things could be cleared up, the tight schedule forced everybody off the stage. Fortunately a review of the notes taken by the beautiful, but slightly numerically challenged hostesses responsible for the counting followed. In the end it turned out that GhostDoc received three votes more than SharpDevelop. Three votes. Funny, that’s two votes by guys of my .NET user group, and one vote by somebody who later told me that he had no idea what GhostDoc was before I gave my elevator speech on stage.

    2006–10–20: Whoops... I Just Asked a Question and Now I Won a Prize… Strange stuff happens to me at the Microsoft Visual Studio Extensibility Contest.

    2007–01–30: A chapter on GhostDoc in yet another book. Needless to say, mum and dad are proud again.

    2007–05–01: GhostDoc 2.0.0 is out. No more thanking my girlfriend in the help file – we married one week after the release of 1.9.5 in August 2006. Version 1.9.6 took much longer than expected and finally became 2.0.0. The huge number of downloads makes me check my hosting package. OK, enough headroom left for many more downloads.

    2007–06–24: GhostDoc 2.1.0 is out. VB.Net developers love me again.

    2007–07–02: Four years of blogging. Time flies by. Development on GhostDoc will slow down again over the next months as I’ll be working on another hobby project. But I’ll stay in touch with the topic of Visual Studio Extensibility – GhostDoc has turned me into a speaker. Small user group meetings (Paderborn, Leipzig, Braunschweig), the BASTA! conference in September and other appearances are in the pipeline. Things promise to stay interesting.

    OK, enough blogging, back to preparing the talk on Friday.

  • Vortrag über Visual Studio Extensibility in Leipzig

    No Comments

    Am nächsten Freitag, 6.7.2007, bin ich um 19:30 bei der .NET User Group Leipzig zu Gast und halte dort einen Vortrag über Visual Studio Extensibility.

    Die Themen des Vortrags an diesem Abend:

    • Code Snippets
    • Project/Item Templates und Wizards
    • Makros
    • Add-ins

    Ein gewisser Schwerpunkt wird beim Thema Visual Studio Add-ins liegen, wo ich u.a. auf den einen oder anderen Fallstrick hinweisen werde, über den ich bei der Entwicklung von GhostDoc gestolpert bin.

    Die Teilnahme ist kostenlos, eine Anmeldung ist erforderlich. Laut dem Organisator Torsten Weber laufen die Anmeldungen gut, noch ist aber Platz für weitere Interessierte.

    Anmeldung und weitere Infos hier

  • GhostDoc 2.1.0 Released

    6 Comments 
    <summary>
    GhostDoc is a free add-in for Visual Studio that automatically generates XML
    documentation comments for C#. Either by using existing documentation inherited
    from base classes or implemented interfaces, or by deducing comments from
    name and type of e.g. methods, properties or parameters.
    </summary>

    20070624_GhostDocQuick Facts

    • Support for VB.Net added
    • Full support for events, including inherited documentation and user-defined custom rules.
    • Download on the GhostDoc Website
    • Users of earlier versions: Please read the ReadMe on upgrading!

    About this Release

    For Visual Basic developers, version 2.1 is what 2.0 should have been: VB.Net support has been added again. Even though I got help (huge thanks to Daniel Root for the translation of the demo project), I spent more time than I wanted on testing, debugging and deployment – in the end it’s a huge number of small things that add up.

    C# developers who have to implement many interfaces with events (like I do) will enjoy the full support for events, as it includes a text generation rule for using inherited documentation (VB.Net developers benefit from this of course, too).

    What’s New in GhostDoc 2.1.0:

    • Added: Support for Visual Basic .NET has been added again (was disabled in version 2.0.0), but still is regarded as "experimental". The feature is turned off by default and you have to turn it on in the configuration dialog. Please see the docs for more information.
    • Added: The setup for the demo project now contains a VB.Net version.
    • Added: Full rule support for events (configurable default documentation, inherited documentation e.g. for interface implementations, and used-defined custom rules)
    • Added: New macro $(DeclaringTypeKind) that specifies the kind of type a member is defined in (i.e. class, struct or interface).
    • Changed: All occurrences of "class" in the default templates have been replaced by $(DeclaringTypeKind).
    • Changed: As the next version of Visual Studio (codename "Orcas" ) will be named Visual Studio 2008, all texts have been updated accordingly.
    • Fixed: Documentation of constructors of structs referring to the initialization of a "class" instance.
    • Fixed: Problems with parameter names starting with an '@' (e.g. "@class").

  • Visual Studio Add-ins at BASTA!

    2 Comments

    20070605_Basta I’ve received an email that I was accepted as a speaker for the BASTA! conference in September in Mainz, Germany . The topic will be the development of add-ins for Visual Studio 2005.

    There’s a thing or two that I learned while working on GhostDoc that I’d like to share. My goal is to show both how easy it is to write and debug a simple add-in to be used just by yourself (and maybe your closest buddies), and what it takes to create a “production quality” add-in that runs on the various language versions of Windows and/or Visual Studio.

    This will be my first “large” conference as a speaker and I’m sure it will be pretty exciting. Good thing that I’ll have a “warm-up phase” in the next months, speaking about Visual Studio extensibility in general at various .NET user groups (more on that soon).

    Note to self: Things to avoid as a speaker

  • GhostDoc: Support for VB.Net?

    3 Comments

    Even though GhostDoc is a tool for C# developers, I had (experimental) support for VB.Net in the 1.9.x versions of GhostDoc. When I had to cut down the feature set for version 2.0.0, I cut the features I cared for the least (that’s the freedom of a hobby freeware project). Well, not being a VB.Net developer at all, VB.Net support was one of those.

    After the release, more people than expected have asked about VB.Net support for 2.0.0., so even though I’m not a VB.Net developer and I’m not exactly highly motivated to work on VB.Net support, I’ve decided to take a look into this for the next version. No promises on a release date and if I run into larger problems (which I don’t expect, it should all be a matter of working around slight differences in the Visual Studio file code model), I reserve the right to punt the feature to a later version.

    What you VB guys could do is to help me by translating the demo project of 2.0.0 to VB.Net syntax and sending it to me. Sounds like only a small thing, but this definitely would save me some time.

    Update 2007–06–04: A huge “Thank You” to Daniel Root for the translation of the demo project.

  • GhostDoc News

    No Comments
    • GhostDoc 1.9.5 mentioned in MSDN Magazine June 2007
      Surprise… I just had skipped the ads when the title “Quickly Add XML Comments to your Visual Studio Projects” caught my eye on page 11. Nice little article and I especially like the last paragraph, where the author (Scott Mitchell) shows that he really “gets it”, instead of falling into the trap of being overly enthusiastic about GhostDoc’s capabilities.
    • Two weeks of GhostDoc 2.0.0
      On May 1st I released version 2.0.0 of GhostDoc. Here’s what happened in the last two weeks so far:
      • 203 downloads of version 1.3.0 (still many people forced to use VS.Net 2003, it seems)
      • 87 downloads of version 1.9.5 (some deep linking)
      • 118 downloads of GhostDoc 2.0.0 for Orcas
      • 2809 downloads of GhostDoc 2.0.0 for Visual Studio 2005
      Whoa.. the first thing I did was checking the bandwith limit of my webhoster (phew, no probs here ;-).
    • My Amazon wish lists
      After receiving four books off my GhostDoc wish list(s) in 2006, I’m happy to report that this number has already been surpassed in the first five months of 2007. I’d like to say a big Thank You!

  • GhostDoc 2.0.0 Released

    16 Comments 
    <summary>
    GhostDoc is a free add-in for Visual Studio that automatically generates XML
    documentation comments for C#. Either by using existing documentation inherited
    from base classes or implemented interfaces, or by deducing comments from
    name and type of e.g. methods, properties or parameters.
    </summary>

    20070501_GhostDocQuick Facts

    • Support for Vista out of the box
    • Support for Orcas (tested: Beta 1)
    • Better support for generics, more language elements, new rules, new macros
    • Download on the GhostDoc Website
    • Users of earlier versions: Please read the ReadMe on upgrading!
      (The file is contained in the ZIP file)

    About this Release

    Version 2.0 is the first real feature release for a long time. Originally intended to be a minor update to fix installation problems on Windows Vista (and to be called 1.9.6), it ended up much larger than I had planned. In the second week of April I had the opportunity for almost one week to work exclusively on GhostDoc, so I used the time to implement the features I was missing the most in my everyday, non-GhostDoc-related work. Along the way I was able to implement a few of the external feature requests waiting in my issue tracking database.

    What then followed was what could best described as deployment hell, but I must admit that I was being extra ambitious, targeting a simultaneous release of (separate) versions for Visual Studio 2005 and Orcas plus Vista compatibility (which in my case required a little more than simply patching an MSI). Building and testing setups plain sucks, period. No matter how careful you plan things (very carefully), how much automated your build process is (very automated) or how intensely virtual machines are used (very intensely) – the moment you modify a working setup, you’re doomed. There’s always one more typo, one more slight problem; it seems as if you’re never finished.

    OK, enough rambling of a tired developer, here’s the good stuff:

    What’s New in GhostDoc 2.0.0:

    • Added: Support for Visual Studio codename "Orcas". Note that GhostDoc for Visual Studio 2005 and GhostDoc for Visual Studio "Orcas" are released in separate setups and have to be installed into separate folders. Both offer equal functionality and thus share the same configuration file, though. This will stay this way as long as GhostDoc 2.x is released both for 2005 and "Orcas".
    • Added: Support for generic methods. The type parameters are now documented using the <typeparam> tag. For type parameter names starting with 'T' (e.g. "TKey") documentation text is generated (e.g. "Type of the key"), for all other type parameter names the text is left empty. Note that this behavior is currently hard-coded.
    • Added: New text generation rules for classes, interfaces and structs (with support for generic type parameters). The default rules generate empty summaries and place the cursor so you can start typing the summary immediately. It is possible to change the summary template to insert e.g. the class name split into individual words, but honestly I don't want to ship GhostDoc with that behavior by default as I didn't find it too helpful. In addition to the default rules, it's also possible to define custom rules (e.g. for classes with a name ending on a specific suffix).
    • Added: A new macro $(End) for specifying the location of the text cursor after the documentation text has been generated.
    • Added: A new macro $(Rule) that inserts the display name of the rule that generated for documentation text. Useful for debugging custom rules, this macro can e.g. be used in the custom text that is added to new doc comments (see the last tab of the GhostDoc configuration dialog).
    • Added: A macro of the format $(%VarName%) inserts the value of the environment variable with the name "VarName" (or an empty string if no variable with that name exists).
    • Added: A few language elements are now supported with limited functionality, i.e. without specific rule types (new rule types may be added in future versions, but they didn't have a high priority to be included in 2.0 as the existing functionality already helps a lot):
      • enums - empty summaries for the enum and all of its values
      • enum values - empty summary
      • events - summary starting with "Occurs when"
      • delegates - empty summary
      • variables - empty summary
      The cursor is moved inside the summary tag so you can start typing right away. As usual, existing documentation will not be overridden.
    • Added: New method rules:
      • A rule for Dispose(bool disposing)
      • A rule for overloaded operators
      • Rules for implicit/explicit conversion operators
      On a side note, these new rules have been implemented using custom method rules, i.e. using only what was already available in earlier versions of GhostDoc.
    • Added: Before upgrading or importing a configuration, it is now possible to quickly create a backup copy by clicking the link in the lower left of the dialog. This is useful especially during an upgrade installation.
    • Changed: The experimental support for VB.Net has been disabled in this release. I was pretty tight on my time budget and couldn't spend any time on keeping support for C# and VB.Net in sync.
    • Changed: The demo project is no longer installed to a sub-folder of the GhostDoc directory (where it caused problems when working with a non-admin account). Instead, the demo project is now an optional feature with its own setup, suggesting an installation path in the user's Visual Studio project folder.
    • Fixed: Error message when installing GhostDoc by double-clicking the MSI file on a Vista system.
    • Fixed: When defining custom rules, conditions for method and type names didn't work well with type parameters (generics).
    • Fixed: The "Document this" command worked only when the cursor was positioned in a specific way. This has been relaxed, the cursor may now also be positioned on the whitespace before the language element (in the same line as the identifier), or somewhere inside the documentation comment.

    Update 2007–05–02: Please guys, please read the instructions on upgrading in the ReadMe!

  • Folien für "Visual Studio anpassen und erweitern" online

    No Comments

    Am Montag waren Jens Schaller und ich bei der .NET User Group Paderborn zu Gast, um einen Vortrag über Anpassung und Erweiterung von Visual Studio 2005 zu halten. Wir hatten ingesamt 15 Zuhörer, angesichts des tollen Wetters eine durchaus erfreuliche Zahl.

    20070405_Paderborn1 20070405_Paderborn2

    Die Folien für die Vorträge liegen nun zum Download bereit (PowerPoint 2007, PowerPoint 2003).

  • Visual Studio anpassen und erweitern - in Paderborn

    2 Comments

    Mein Kollege Jens Schaller und ich sind am 2. April 2007 bei der .NET User Group Paderborn zu Besuch, wo wir ab 18:00 einen Vortrag mit dem Titel “Visual Studio anpassen und erweitern” halten werden.

    Auf der Agenda stehen:

    • Code Snippets
    • Project und Item Templates
    • Makros
    • Add-ins
    • Packages

    Das ist natürlich eine Menge Stoff für einen Vortrag, deshalb werden wir flexibel auf die Interessenslage der anwesenden Zuhörer reagieren. Einen gewissen Schwerpunkt wird es beim Thema “Add-ins” geben, wo wir beide auf unsere Erfahrungen aus der Entwicklung unserer jeweiligen Hobbyprojekte  SonicFileFinder (Jens) bzw. GhostDoc zurückgreifen können.

  • Microsoft Community GetTogether auf der CeBIT (non-english post)

    No Comments

    20070318_GetTogetherLogoGestern trafen sich MVPs, CLIP-Mitglieder und Leiter von INETA .NET User Groups auf der CeBIT zum “Microsoft Community GetTogether”. Die Veranstaltung bot eine Reihe von Vorträgen zu den Themen User Experience, IIS 7.0 und UI Technologien (an dieser Stelle vielen Dank an Oliver Scheer dafür, dass er für seinen Vortrag die Schriftart im Editor auf Verdana umgestellt hat ), aber ganz klar im Vordergrund stand das Knüpfen und Pflegen von Kontakten. Dafür hatten die Veranstalter auch genügend Raum eingeräumt, so z.B. durch eine zweistündige Mittagspause, die trotzdem irgendwie viel zu schnell vorbei war. Es war schön, so manchen nach endloser “Emailerei” endlich auch mal in Person zu treffen. Für mich persönlich war es auch erfreulich zu erfahren, wie viele Entwickler GhostDoc einsetzen. Und die eine oder andere Support-Anfrage konnte dann auch gleich direkt vor Ort beantwortet werden…

    20070318_UGLeaderNach dem offiziellen Teil der GetTogether-Veranstaltung versammelten sich schließlich die Leiter der INETA User Groups zu einem eigenen Treffen. Einer Vorstellungsrunde, in der die Gruppenleiter jeweils ein paar Worte zu ihrer Gruppe sagten, folgte ein Rückblick auf das vergangene Jahr durch Hardy Erlinger (Leiter der INETA Deutschland). Die große Zahl von neugegründeten Gruppen ist ein eindeutiges Zeichen für das stetig wachsende Interesse an .NET und den damit verbundenen Technologien.

    Anschließend ging es um die weitere Entwicklung. Ohne auf die einzelnen Punkte eingehen zu wollen (vieles davon ist zum jetzigen Zeitpunkt noch nicht spruchreif), so kann man doch sagen, das es in Zukunft einen verstärkten Austausch von Know-How und Sprechern zwischen den einzelnen Gruppen geben wird. Die Bonner User Group “Bonn-to-Code.Net” wird in den nächsten Monaten Besuch aus Frankfurt erhalten, im Gegenzug wird der Vortrag von Jens Schaller und mir über “Visual Studio Extensibility” (nach Paderborn) auch in Frankfurt zu hören sein.

    Alles in allem war das Microsoft Community GetTogether eine sehr gelungene Veranstaltung und ich freue mich – nicht zuletzt wegen der vielen netten Leute, die ich dort getroffen habe – schon auf zukünftige Treffen.

  • Wie gründe ich eine .NET User Group?

    No Comments

    Eine .NET User Group ist nicht zuletzt deshalb eine tolle Sache, weil man auf den regelmäßigen Gruppentreffen tatsächlich  mal "echte Menschen" trifft. Da diese Treffen üblicherweise an Wochentagen stattfinden, sollte die Gruppe allerdings einigermaßen in der Nähe gelegen sein, schließlich will man nach einem normalen Arbeitstag nicht auch noch Stunden auf der Autobahn verbringen. Nur: was ist, wenn sich partout nichts in der Umgebung finden lässt?

    Nachdem ich einige Zeit lang erfolglos nach einer .NET User Group in der Nähe von Bonn Ausschau gehalten hatte, gründete ich im Januar 2006 eine eigene Gruppe mit dem Namen Bonn-to-Code.Net (die Ehre für das grandiose Wortspiel gebührt übrigens einzig und alleine meinem Kollegen Jens Schaller ;-). Ich habe den Entschluss nie bereut, denn die Gruppe läuft sehr erfolgreich und macht jede Menge Spaß. Natürlich muss man schon ein wenig Arbeit in die Organisation investieren, aber das wird durch viele neue interessante und nette Kontakte mehr als aufgewogen.

    Aus den persönlichen Erfahrung heraus habe ich einmal diverse Tipps zusammengestellt, die die erfolgreiche Gründung einer User Group erleichtern können.

    Empfehlung: Zuerst einen Veranstaltungsort suchen

    Man kann sicherlich erst die Gruppe gründen und sich dann nach einem geeigneten Ort für die Treffen umsehen - evtl. in der Hoffnung, dass ein anderer Interessent einen Raum anbieten kann. Die Ausgangssituation für das Anwerben von Mitgliedern ist jedoch eine ganz andere, wenn dieses Thema von Anfang an geklärt ist.

    Ich persönlich hatte das Glück, die hervorragend ausgerüsteten Konferenzräume meines Arbeitgebers nützen zu können, der davon allerdings auch zunächst einmal überzeugt werden wollte.

    Mal probieren: Den Arbeitgeber überzeugen

    Wer darüber nachdenkt, ebenfalls beim Arbeitgeber nachzufragen, sollte gut vorbereitet sein. Zunächst empfiehlt es sich, eine Liste mit Risiken und Chancen zu erstellen:

    • Was sind die Risiken?
      • Öffentliche Veranstaltungen in Firmenräumen stellen grundsätzlich ein potentielles Sicherheitsrisiko dar.
      • Externe Entwickler könnten von firmeninternem und evtl. sehr speziellem Know-How profitieren
      • Gute Mitarbeiter haben nach außen eine erhöhte Sichtbarkeit (z.B. durch Vorträge) und könnten evtl. abgeworben werden.
      • usw.
    • Was sind die Chancen für die Firma?
      • Die Fortbildung der eigenen Mitarbeiter wird gefördert, ohne dass die Firma dafür Zeit oder Geld bereit stellen müsste.
      • Frische Konzepte und Ideen können von außen in die Firma hinein getragen werden.
      • Die Firma erhält Gelegenheit zu demonstrieren, dass sie ein attraktiver Arbeitgeber ist. Dabei wird der Bekanntheitsgrad gerade bei den Entwicklern erhöht, die dadurch interessant sind, dass sie eine gewisse "Energie" haben und sich nach einem Arbeitstag auch noch Abends um ihre Fortbildung kümmern.
      • usw.

    Darüber hinaus sollte man sich auf mögliche Fragen vorbereiten, und diese auch ruhig von sich aus vorwegnehmen:

    • Was sind die Kriterien, nach denen Mitarbeiter entscheiden können, über welche Themen sie auf einem Treffen sprechen können? Klar ist: wenn man etwas in fünf Minuten über Google findet, kann es kein Geschäftsgeheimnis sein - aber wo liegen evtl. Grenzfälle?
    • Wie wird sichergestellt, dass kein Besucher unbeaufsichtigt im Firmengebäude umherwandern kann? Im Zweifelsfall müssen Besucher bis zu den Toiletten begleitet werden (z.B. gängige Praxis bei Bonn-to-Code.Net, auch weil einige Flurtüren Abends abgeschlossen sind).
    • Wie wird sichergestellt, dass sich kein Besucher in's Netzwerk einklinkt?
    • usw.

    Eine gute Vorbereitung vor einer Anfrage beim Arbeitgeber demonstriert auch, dass man verantwortungsvoll und im Interesse der Firma handelt.

    Bloß nicht übertreiben: Die Website aufbauen - aber richtig!

    Das ist ein Punkt, bei dem man vieles falsch machen kann. Deshalb einige wichtige Punkte:

    • Zunächst klein und einfach anfangen.
      Es bringt nichts davon zu träumen, was man mit Foren, Wikis etc. anfangen könnte. Damit so etwas auf Dauer funktioniert, ist eine gewisse "kritische Masse" notwendig, und die ist schon im Internet schwer zu erreichen, geschweige denn im Kontext einer lokalen User Group.

    • Im Endeffekt zählen die Inhalte.
      Vollkommen egal, ob man mit einem CMS oder einer einzelnen HTML-Seite anfängt: das Wichtigste ist, dass sich regelmäßig etwas auf der Website tut. Man kann z.B. in der Art eines Weblogs die Schritte bei der Gründung der User-Group beschreiben. Auch hier gilt wieder: beim Stichwort Weblog nicht zuerst an die Technik denken (Kommentare, Trackbacks, Pings), sondern an die Inhalte - und die kann man am Anfang auch einfach auf eine statische HTML-Seite schreiben.

    • Die menschliche Seite nicht vergessen
      Bei meiner Suche nach einer Gruppe fielen mir eine Reihe von User Group Websites auf, die einen recht anonymen Eindruck machten. Dabei spielte es keine Rolle, ob sie sich auf das absolute Minimum beschränkten oder technisch aufwändig gemacht waren. Das Problem war, dass Sie nicht durch Wort und Bild das Gefühl vermittelten, dass dahinter eine Gruppe netter und interessanter Menschen steht. Insbesondere dann, wenn man als Besucher noch überlegt "ob so eine User Group überhaupt etwas für mich ist", sind es kleine Details die entscheiden, ob man sich den entscheidenen Ruck zur Kontaktaufnahme gibt. Und wenn man als Gründer am Anfang ganz alleine da steht: Warum nicht einfach auf die Website schreiben: "Hallo, ich bin X, interessiere mich für Y und Z und möchte eine User Group gründen". Ganz einfach, menschlich und sympathisch.

    • Nichts "verkaufen".
      Sicherlich gibt es Vorteile für die Mitglieder einer in der INETA organisierten User Group (z.B. Rabatte beim Kauf von Software und Büchern), aber das sollte nicht im Vordergrund stehen. Es geht ja nicht darum, Kunden zu suchen und zu überzeugen, es geht einfach nur darum dass sich ein Haufen von netten Leuten zusammenfindet und Spass hat.

    • Narrensichere Anfahrtsbeschreibung
      Jedes Bisschen Zeit, das darin investiert wird, kann im Zweifelsfall einen Besucher mehr oder weniger bedeuten ;-)

    Alles ist erlaubt: Werbung machen

    Für die Werbung sollte alles genutzt werden, was möglich ist. Manchmal reicht es schon, wenn mit einer Werbeaktion eine einzige Person angesprochen wird, weil die wiederum jemanden kennt, der jemanden kennt, usw. Also: Werbung im eigenen Weblog (soweit vorhanden), auf Community-Sites wie z.B. Codezone.de oder auch Netzwerken wie XING. Flyer, Poster, Aushänge - an der Uni, im Baumarkt, in Computerläden, alles ist erlaubt.

    Jetzt wird es ernst: Das erste Treffen planen

    Wie man an das erste Treffen herangeht, dafür gibt es sicherlich eine ganze Reihe Möglichkeiten. Zwei sehr unterschiedliche Ansätze, die ich persönlich erlebt habe (mit Bonn-to-Code.Net und in der Kölner Gruppe DNUG Köln) haben beide zum Erfolg geführt:

    • Die Teilnehmer stellen sich zunächst einmal vor.
      In Bonn bestand das erste Treffen alleine aus kurzen "Mini-Vorträgen" auf jeweils zwei bis drei PowerPoint-Folien, in denen jeder Teilnehmer sich und seine Interessen vorstellte. Dieser Ansatz skaliert natürlich nicht sonderlich gut (ab etwa 15 Personen wird es kritisch), aber rückblickend hat dies die Gruppe sehr schnell vorangebracht. Die Teilnehmer haben sich schnell kennengelernt und viele der ersten Teilnehmer gehören bis heute zum harten Kern. Dieses Treffen hatte keinerlei technischen Inhalte, es ging alleine um zukünftige Themen und einen Termin für das nächste Treffen.

    • Start mit einem "großen Knall"
      In Köln wurde für das erste Treffen ein relativ bekannter Sprecher für einen Vortrag gewonnen. Es blieb wenig Zeit für Organisatorisches, und nach dem Vortrag war der Sprecher sehr stark im Fokus des Interesses. Trotzdem läuft die Kölner Gruppe mittlerweile auch erfolgreich. Der Vorteil des "großen" Auftakts war dabei, dass dadurch Teilnehmer angelockt wurden, die nach eigenen Aussagen sonst nicht gekommen wären - viele davon sind heute noch regelmäßige Besucher.

    Es wäre auch ein gemischter Ansatz denkbar, d.h. ein kurzer technischer Vortrag kombiniert mit einer kurzen mündlichen Vorstellungsrunde. Allerdings ist bei der Vorstellung die Kombination von Text, Bildern und Sprache weitaus effektiver, auch deshalb, weil sich die Leute zu Hause in Ruhe Gedanken machen können, wie sie sich präsentieren wollen.

    Es kommt schneller als man denkt: Das zweite Treffen

    Natürlich wäre es ideal, wenn sich bereits beim ersten Treffen herauskristallisiert, dass man einen ganzen Pool von potentiellen Vortragenden zur Verfügung hat. Da dies in der Praxis nicht unbedingt der Fall sein muss, sollte man für das zweite Treffen einen "Plan B" haben - im Notfall indem man als Gruppenleiter selbst einen Vortrag hält. Wichtig dabei: Auch wenn man eine ganze Reihe von Themen hat, über die man sehr gerne einen Vortrag halten würde, sollte es zunächst höchste Priorität haben, möglichst schnell andere in das Halten von Vorträgen einzubinden. Dies führt uns auch gleich zum nächsten Punkt.

    Einstiegshürden senken: Schnell neue Sprecher gewinnen

    Die Vorbereitung eines Vortrags ist harte Arbeit. Dies kombiniert mit einer gewissen Scheu, vor Publikum zu sprechen, sorgt dafür dass einige, die eigentlich dafür qualifiziert wären, keinen Vortrag halten. Eine User Group lebt aber davon, dass sich möglichst viele Personen einbringen. Es gibt diverse Möglichkeiten, potentiellen Sprechern entgegen zu kommen, in dem man einige der typischen Einstiegshürden senkt:

    • Angebot einer fertigen PowerPoint-Vorlage
      Nicht jeder ist ein Könner im Umgang mit PowerPoint. Eine bereits vorbereitete Vorlage hilft Nicht-Designern, sich auf die Inhalte zu konzentrieren und trotzdem attraktive und lesbare Vorträge zu gestalten. Gleichzeitig sorgt man für ein gewisses "Branding", wenn die Folien ein einheitliches Aussehen im Design der User Group haben. Selbstverständlich sollte die Verwendung der Vorlagen freiwillig sein.

    • Einführung des Konzepts eines "QuickTips"
      Nicht jeder Vortrag muss unbedingt ein stundenlanges Epos sein. Manchmal ist es vielleicht nur ein Hinweis auf einen Hotkey, eine kleines Tool oder eine Website, die dafür sorgt, dass die Teilnehmer eines Treffens mit dem guten Gefühl nach Hause fahren, dass sich der Besuch gelohnt hat. In der Bonner Gruppe besteht ein QuickTip nur aus wenigen Folien: Was ist das Problem, was ist die Lösung, vielleicht eine kurze Demo (die man z.T. aber auch mit Screenshots simulieren kann, was den Aufwand drastisch reduziert) - fertig.

    Es gibt viel mehr talentierte Sprecher in den Reihen einer User Group, als man vermuten mag, man muss sie nur finden. Das Wichtigste ist, jemanden zu einem ersten Vortrag zu bewegen. Wenn der gut gelaufen ist, ist der nächste Vortrag ein viel geringeres Problem.

    Also: Auf geht's!

    User Groups machen Spass, bringen viele neue Kontakte und man lernt eine ganze Menge dabei. Und wenn in der näheren Umgebung keine zu finden ist, dann wird es höchste Zeit, durch Gründung einer eigenen Gruppe Abhilfe zu schaffen...

  • SonicFileFinder 1.8 Released

    No Comments

    My colleague Jens Schaller has released a new version of SonicFileFinder, a free add-in for Visual Studio 2005. SonicFileFinder adds a fast search for files in the current solution, just by entering parts of the file name. This is definitely one of those tools I install on every development machine I work on.

    The new version has a long list of additions and fixes, my personal highlights are (in no particular order):

    • Opening the Windows Explorer for the selected file will now not only open the containing folder, it will also select the file.
    • The feature “Search by Initials” now works with partial matches. For example typing the uppercase letters “PB” will find “PrefetchBuffer.cs” as in earlier versions, but also “PrefetchBufferManager.cs”, “PrefetchBufferException.cs” etc.
    • Fixed support for multi-monitor systems (nice if you have multiple copies of Visual Studio opened on different monitors)

    Jens has also added Vista compatibility for the installer – before anyone is asking: yes, I’ll add that to GhostDoc in the next minor release (no idea regarding a release date yet, I’m currently busy finishing an important part of another hobby project). In the meantime, there’s a workaround, see the GhostDoc website for more information.

    Update 2007–02–23: Jens just put up a bugfix release (SonicFileFinder 1.8.1)

  • Custom Editing Behavior for DataGridView TextBox Columns

    3 Comments

    I’m currently working on a hobby project where I’m displaying a list of files in a way similar to the “details” view of Windows Explorer. For various reasons I’m using a DataGridView instead of a ListView, and while configuring the DataGridView to look like a ListView wasn’t much of a problem, there’s one thing that got on my nerves, which is the behavior of textbox cells in edit mode: It is much too easy to leave the edit mode accidentally, simply by pressing the cursor keys at the wrong time. For example when the text caret is positioned behind the last character of the textbox cell content, and you press the right arrow key: the focus then moves to the next cell. There are certainly use cases for this behavior, but for my purposes I wanted the text caret to be “captured” inside the textbox in edit mode until you press Enter, Tab or Escape (or use the mouse to click another cell).

    The nice thing about the DataGridView is that you can tweak it a lot by deriving from existing classes for cells, columns and editing controls, overriding certain methods. In my case I suspected that the DataGridViewTextBoxEditingControl (derived from TextBox) would contain special code to determine when the cell should leave edit mode. As I didn’t know what to search the documentation for (and I was too impatient to read it completely, to be honest), I fired up Lutz Roeder’s Reflector and took a look at the decompiled code of the class members. With the option “Show Inherited Members” switched off it took me only a couple of seconds to come across the code of the EditingControlWantsInputKey method which looked exactly like what I was expecting (lucky me: it was the 4th member in the list ;-).

    So here are the steps to change the behavior of the editing control:

    First derive a class from DataGridViewTextBoxEditingControl and override the EditingControlWantsInputKey method:

    public class CustomDataGridViewTextBoxEditingControl
        : DataGridViewTextBoxEditingControl
    {
        public override bool EditingControlWantsInputKey( Keys keyData, bool dataGridViewWantsInputKey )
        {
            switch (keyData & Keys.KeyCode)
            {
                case Keys.Prior:
                case Keys.Next:
                case Keys.End:
                case Keys.Home:
                case Keys.Left:
                case Keys.Up:
                case Keys.Right:
                case Keys.Down:
                case Keys.Delete:
                return true;
            }
            return base.EditingControlWantsInputKey( keyData, dataGridViewWantsInputKey );
        }
    }

    Then derive a class from DataGridViewTextBoxCell and override the EditType property to use the customized editing control:

    public class CustomDataGridViewTextBoxCell
        : DataGridViewTextBoxCell
    {
        public override Type EditType
        {
            get { return typeof( CustomDataGridViewTextBoxEditingControl ); }
        }
    }

    Finally derive a class from DataGridViewTextBoxColumn to be able to use the new cell type.

    public class CustomDataGridViewTextBoxColumn
        : DataGridViewColumn
    {
        public CustomDataGridViewTextBoxColumn()
            : base( new CustomDataGridViewTextBoxCell() )
        {
        }
    }

    You can now use the new column type in your code as a replacement of the stock DataGridViewTextBoxColumn (the new type appears in the drop down lists for column types in the designer dialogs of the DataGridView control).

    A demo project is available here, showing a DataGridView with a normal DataGridViewTextBoxColumn and the CustomDataGridViewTextBoxColumn next to each other, so you can compare the different behaviors.

  • GhostDoc in "Windows Developer Power Tools"

    1 Comment

    20070130_WindowsDeveloperPowerToolsToday I received my copy of “Windows Developer Power Tools” by James Avery and Jim Holmes, to which I contributed a chapter about my Visual Studio add-in GhostDoc, comparable in scope to what I wrote for “Visual Studio Hacks”. For the chapter in “Tools” (which grew to 7 pages compared to 5 in “Hacks”), I took the opportunity to be more clear about what GhostDoc can do, and what it cannot achieve, and what to look out for e.g. when re-using inherited documentation.

    A small error was introduced in editing of my original text (which by the way turned out surprisingly tame considering the fact that English is not my native language): Unlike suggested by the text on page 314 “when you want to document a method or class”, GhostDoc does not generate documentation for classes. On a sidenote: While this is a feature that has been requested a couple of times, it hasn’t been implemented yet. And honestly, I’m not quite sure of the value of such a feature, let alone what exactly it is supposed to do (most of the examples I have received so far show a certain ELIZA effect concerning the belief in GhostDoc’s abilities, but I’m still open to suggestions).

    To bring the topic back to the book: at more than 1300 pages, it contains a lot of stuff, covering more than 170 free and open source tools for developers. The concept of the book is to describe each tool on roughly 3 to 10 pages, helping you to decide whether or not to give it a shot, and if so, how and where to start. If “Windows Developer Power Tools” saves you from either missing a really good tool, or installing some crud software in the process of finding one, the book has reached its goal and saved you a lot of time (and maybe even trouble). As one reviewer puts it “You could spend your time tracking down these applications, but why?”. From what I can tell by a first quick glance at the table of contents and skimming the pages, definitely an interesting book.

  • Five Things about Me

    No Comments

    The game of blog-tag has finally reached me: i got tagged by Albert. While this is obviously a pyramid scheme which at some point will collapse, I must admit that I have enjoyed reading the “five things” entries of other bloggers so far. So here we go, five things you probably don’t know about me:

    • As a child back in the 70s, the children’s TV series “Wickie der Wikinger” (Vicky the Viking) and “Sendung mit der Maus” have played a big role in getting me interested in science and technology.
    • At primary school, I was the first in my class to borrow a book from the public lending library in our school building. I went to the library on the day we received the ID cards, right after school, even though I knew that I would miss the school bus (that was before I was allowed to ride the bike to school); fortunately the walk home was only 20 minutes. The first book I borrowed was a children’s book about the exploration of space.
    • I have a long list of failed hobby projects in the time between 1983 and 1986. Overambitous designs, fragile architectures collapsing after minor changes, lack of documentation causing incomprehensible code, loss of interest after a few weeks – all the things you can expect from a typical teenager. Looking back I learned some of the most valuable lessons in that time.
    • I once wrote a Sidekick clone called SideWorx for the 8bit computer CPC 464 (by Amstrad, sold by Schneider in Germany). Even though the program worked very well with other programs, its reliance on a rarely-used third-party memory expansion kit prevented any success. Computer magazines I sent the program to ignored it, presumably because the editors weren’t able to try it out. This was before the Internet and access to a BBS was out of reach for me at that time, so without any chance to spread the word, SideWorx had in total the impressive number of four users (my father, two of his colleagues, and myself).
    • As a student at university, I got hired more or less immediately after using a self-written tool in a programming class. Students had to develop a program in Turbo Pascal, teaming up in pairs. I ended up with some other guy I didn’t know and we started coding. After some time we ran into a situation where we needed to modify the source code in a very repetitive way. I left the IDE, grabbed a disk out of my backpack and started up a text editor with a macro recorder. The other guy asked where I got the editor from and I told him that I wrote it myself. What I didn’t know was that he – at age 19 – had his own software company and a fat BMW standing in front of the university building…

    Next bloggers: Thomas, Sascha, Mathias, Sonu, Kay.

  • Ten Years at Comma Soft

    2 Comments

    Today, exactly ten years ago, I started working at Comma Soft here in Bonn, Germany, coming straight out of university. Just amazing how fast time has gone by. Ten years at the same company is even more amazing considering the fact that I originally had planned to stay maybe one or two years, just enough to gain some professional experience, and then move on.

    But towards the end of 1997 I joined what would later become the infonea product team. Working in a team of nice and intelligent people (neither nice bozos nor intelligent back-stabbers are helpful in the long run), using a wide array of different technologies over the years, made me stay. And I'm pretty sure that I may stay just a bit longer, because there must be really good reasons to leave a workplace where I have these two very nice TFT monitors (24” @ 1920x1200 + 20” @ 1650x1080) on my desk ;-)

    20070115_Workplace
    (Photo published with kind permission of Comma Soft AG)

    Update: The story "How I got Hired Straight out of University" is now online.

  • Part 6: How I got Hired Straight out of University

    No Comments
    (Just in case you're wondering where the missing parts 3 - 5 are... they will be added.... someday ;-)

    How I got Hired Straight out of University

    Monday, January 6th, 1997: This was the first day of the new year back at the Institute of Physics at Bonn University, and at the same time I knew it was about to be one of my last days. The past 14 months I had worked on my diploma thesis, which involved developing a C++ library for accessing data acquisition and motor controller modules for various bus systems. I had already turned in the thesis paper and given a talk about the project back in December, but had to wait for the results. In the meantime I was wrapping up loose ends in the code base, getting ready to move out the office, and surfing the web for a job as a software developer.

    While I did have a (somewhat vague) job offer at a company I had worked for as a student, the actual job interview (more or less pro forma I was assured) had been delayed over and over again as an important meeting deciding on how many people should be added to the company hadn’t taken place. It was now scheduled for end of January ("this time for sure").

    After some time in my office I thought a hot chocolate would be nice. I went to the vending machine in the hallway, where I ran into one of the two professors who had read and evaluated my thesis paper. The professor told me he liked my work and asked me about my plans after university. When I answered that I was looking for a job as a software developer, he said he knew some people at a local company and could make a contact. Of course I accepted his offer, but having been promised many things in my life before (with only a fraction actually coming true) I remained a bit sceptical. It was quite a surprise when only 15 minutes later I received an email from a person at Comma Soft, asking me to call him on the phone. I called and we talked a bit about my work. After about 10 or 15 minutes he asked me if I’d like to come over for a job interview – the next day!

    Tuesday, January 7th: The job interview. I was nervous, my heart pounding. After all, it was my very first job interview, ever. The interview wasn’t done by the person I had talked to on the phone, but two developers. The interview started with some questions about my diploma thesis which went pretty well. After that came questions about how I would approach future  projects, how I would design class hierarchies, what I thought about multiple inheritance, and so on - nothing too technical. Then one of the interviewer changed the topic:

    • Interviewer: "Ok, let's see... Well, we could ask you about X…"
    • Me: "..." (hmm, I hope he won’t go too deep)
    • Interviewer: "…or we could ask you about Y"
    • Me: "…" (ouch, I’d have to look that up)
    • Interviewer: "But these are things that we assume you either know…"
    • Me: "…" (hmm…)
    • Interviewer: "…and if you don’t, you could look them up."
    • Me: "…" (phew)
    • Interviewer: "So here’s a question that may be a bit unfair, I’m not sure, just to get a picture of you, not necessarily a problem if you can’t answer that…"
    • Me: "…" (uh uh, this doesn’t sound good…)
    • Interviewer: "Do you have a rough idea what a C++ compiler does with virtual methods behind the scenes, i.e. how they are translated?"

    Tons of rocks dropped from my heart. What a coincidence.

    When I started my diploma thesis, I had to debunk the myth that C++ was automatically much slower than C, otherwise I wouldn’t have been allowed to use something so "advanced" as C++. Among other things, I had to do perform some benchmarks on the various possible types of C++ function calls (standalone functions, class member methods, and of course virtual methods), compared to C functions calls (standard call, via a function pointer, via a pointer to a function pointer). I included the benchmark for the call via a pointer to a function pointer reasoning that if I had to reproduce in C what I could do with a virtual function call in C++, pointers to function pointers would be something I'd use. Not surprisingly, the times measured were comparable.

    When I started mentioning that fact, the interviewer cut my answer short and said "yeah, there’s this vtable thing, and then these function pointers and stuff, … I guess we stop here, thank you". The two devs left the room, a couple of minutes later the door opened and somebody else came in, turning out to be the person I had talked to on the phone. When he started a monologue about what a great company Comma Soft is, I knew they wanted me. But we didn’t close a deal yet, instead we agreed that I would send them my final results as soon as I got them from university and that I would hear from them.

    Wednesday, January, 8th: In the morning I received my final results (sooner than expected), and faxed them over to Comma Soft. A couple of hours later I received a call from Comma Soft and was asked how much money I wanted. I told the person what the other company was offering, he said that it sounded reasonable and asked me if I would like to come over the following Monday to sign a contract.

    Monday, January, 13th: With the contract ready to be signed, one final question remained: When would be my first day at Comma Soft? I told them I would like to start as quick as possible. At that time I didn’t have money for a journey and my idea of fun was spending my spare time learning Windows programming (prior to that, I had developed in private mostly DOS, and the diploma thesis was for *ix systems). They said "well, we don’t have a computer ready for you by tomorrow, but what about Wednesday?". I agreed and signed the contract.

    Wednesday, January, 15th 1997: My first day of work at Comma Soft. Funny, originally I had planned to choose my first company very carefully - and here I was sitting at a desk just nine days after my first contact with an unknown company! On the other hand, the people I met and my overall impression of the company seemed nice enough to convince me. I reckoned that I could start looking for another company if things wouldn't work out, making some money and gaining some experience in the mean time.

    Well, things worked out better than expected. An important step was that in fall 1997 I joined what would later become the infonea team that I’m still a part of. But that's another story...

    P.S. I received an email from the other company at the end of January. Now they were ready for a job interview - but I wasn't anymore.

  • Need a New Year's Resolution? What about User Groups?

    No Comments

    You are a developer by passion. You are interested in new technologies, even in your spare time. You are driven to keep your skills up-to-date. You are reading blogs, maybe you are writing a blog yourself.

    But something is missing.

    The developers around you are different, and you can’t even blame them. Maybe they are busy building a house, their children are keeping them on their toes, a non-computer hobby eats away their spare time – or they are simply working crazy hours and need a well-deserved rest when they get home.

    You would like to get in touch with other developers. The Internet offers a huge number of possibilities to get connected to people all over the world, but let’s be honest, nothing beats meeting “real” people.

    Have you thought about joining a .NET user group?

    At a .NET user group, you’ll find a wide variety of people, coming from different backgrounds, with vastly different skills and experience levels, all united by the common interest in .NET technologies. Most user groups are having regular (e.g. monthly) meetings, where talks are given by members or external speakers – this is were you meet real people, not online personae.

    A good place to find out whether a user group exists in your area is the website of the International .NET Association (INETA) at www.ineta.org. Choose your region and start looking for a nearby user group. If you find a group in your area, things are really easy: go to their website, get in contact and visit one of their meetings.

    If you are wondering whether you are a “user group person”: Don’t be shy or too critical of your own skills – a user group meeting is not a place where you have to prove yourself in any way. If you prefer sitting quietly in the back, you can do just that. Nobody will force you to become a speaker the minute you enter the room.

    Here are a few tips for your first meeting. These are pretty obvious, but being a user group leader myself I have my fair share of experience with first time visitors:

    • Don’t be late (yes, duh). Note that coming late can be a major annoyance, e.g. if the meeting takes place in a company meeting room, where somebody may have to pick you up at the entrance.
    • Come a bit earlier so you can talk to the user group leader or the person you had contact with, or other members. Don't be way too early as that will most likely disturb the preparations (setting up equipment etc). The best thing is to ask your contact for when other members usually start to show up.
    • Prepare a short introduction you can use when talking to other people – who are you, what are you doing, what are your interests. You don’t want to drive home thinking “dang, I should have mentioned I’m very interested in technology X” given the chance that somebody else could have started a conversation “hey, I’m using X, too… what tools are you working with?”.
    • Avoid being under time pressure. Depending on the user group and their meeting location, group members may go to a bar or a restaurant after the “official part” of the meeting. Plan for enough time to join them, it’s the best thing you can do to get in contact with other people.

    But what if the next user group is too far away?

    Have you thought about founding a .NET user group?

    So you didn’t find a user group near where you live. Of course you could wait until a group is founded by somebody else. That’s what I did for almost a year before I eventually founded a group myself in Bonn, Germany called Bonn-to-Code.Net (yup, pun intended, all credits go to my buddy Jens Schaller) – that was exactly one year ago on January 1st, 2006.

    A couple of tips for building a user group:

    • Find a meeting location. Sure, you can found a group first and take care of the location later on (maybe hoping that somebody else has a room to offer), but obviously you are in a much better position with a proper location. I had luck that I could convince my employer (Comma Soft AG) to provide the meeting rooms complete with beamers and a sound system. To convince your employer, write up a list of
      • risks, e.g.
        • Developers from other companies could benefit from specific internal know-how that took a long time to develop
        • Skilled employees are more visible outside the company and thus could be lured away
      • and opportunities, e.g.
        • Generating an influx of know-how and new ideas
        • Providing a venue to show that this company is a cool place to work at, and getting it known among developers (especially developers that share a certain level of “energy” in contrast to people with a 9–5 mindset) 
      Furthermore, ask and answer questions that surely will come up to show that you are acting responsibly:
      • How to determine which topics of everyday work company employees can talk about at meetings (if you find it easily on Google, it's not a trade secret)
      • How to make sure nobody can wander freely inside the company building (e.g. accompanying people to the restrooms)
      • How to make sure no computer of an external person is hooked up to the network
    • Build a website. Lots of what can be done wrong here…
      • For a start, keep it simple. Don’t dream up what could be done with forums, wikis and blogs; you’d need a critical mass that’s hard to reach on the Internet, let alone in the context of a local user group.
      • It’s all about content. It doesn’t matter if you start with a website consisting of a single page whipped up in FrontPage if it’s updated on a regular basis – even if it’s just a blog-style report describing the process of founding a user group. Long-term solutions can be searched for after the first meeting(s). 
      • Remember that user groups are about people. Too many user group websites make it hard to see that. Who are you? What are your interests?
      • Don’t try to “sell” too hard. Yes, there are benefits for the members of a user group (e.g. rebates on software licenses and/or books, see the INETA website for more on that), but that shouldn’t be the focus. You are not looking for customers you have to convince, you are looking for a bunch of devs coming together and having some fun. 
    • Advertise the group.
      Use everything at your disposal: your blog (if you have one), community websites like codezone.com/de, etc. Create flyers, posters – whatever comes to your mind.
    • Take a look at what INETA offers
      On the website you’ll find information on how to start a .NET user group, how to apply for (free) membership, etc. Don’t expect miracles from INETA, but founding a user group and not contacting INETA is plain dumb.
    • Plan the first meeting. There are multiple approaches to a first meeting, two I have witnessed myself (in Bonn and at the neighbour group in Cologne, DNUG Köln) are:
      • Let people introduce themselves and get to know each other
        In Bonn, the first meeting consisted mainly of short introductions on two or three PowerPoint slides. Obviously, this approach doesn’t scale well beyond let’s say 15 people, but looking back this really gave the group a jump start in terms getting to know each other. The evening did not offer any technical content, but dealt with planning future meetings, deciding on topics, etc.
      • Start with a “big bang”
        In Cologne, the first meeting had a well-known conference speaker giving a talk. There was no time for really speaking about organizational issues, and after the event, the speaker was the focus of attention. Nevertheless, the Cologne group is now running successfully. Starting “big” attracted people who otherwise wouldn’t have shown up (by their own honest account), many of them still being members.
      A third approach would to split the time between a talk (given by a speaker that will be a member of the user group) and an organisational part of the evening. People could introduce themselves without support by PowerPoint slides, but that tends to less “sticky” than text and speech.
    • Make sure you have a rough idea for the second meeting. Maybe you are lucky to you have a bunch of “natural born speakers” in your group, eager to give talks. If that is not the case (or if you don’t find enough material for a full evening), have a plan B up your sleeve, i.e. a talk that you could give. Note that your primary goal must be to get other people involved as quickly as possible, which brings us to the next point.
    • Lower the entry barrier for contributions. Preparing a talk takes time and effort, which may put people off. There are things you can do to encourage contributions:
      • Offer a PowerPoint template
        Make it easy to author PowerPoint slides that “fit in”, i.e. have a certain “official user group feel” for those that are not comfortable developing their own design or using a stock template shouting “look at me, I’m a PowerPoint n00b”.
      • Introduce the concept of a “QuickTip”
        Don’t require each talk to be of same length and depth. Sometimes just a hint on a single hotkey, a small tool or a cool website can be enough for the visitors of the meeting to drive back home with a positive feeling. At Bonn-to-Code.Net, a “QuickTip” consists of just a few slides: what’s the problem, what’s the solution, and a short demo (sometimes maybe even just a screenshot).
      There are so many hidden talents out there that could be speakers for you user group, you only have to find them. The most important thing is to get them speaking for the first time – it’s usually less of a problem to convince them to give a second and a third talk.

    New year’s resolutions are about changing something in your life. If you get involved in a user group, you life will change – be it just a little bit (just coming to meet other developers), a little bit more (taking the plunge and contributing a talk here and there), or a whole lot more (founding and running a user group). Whatever you do, be assured you’ll have lots of fun.