Even though I still don’t quite get the rationale for the need to create a new API for this (in contrast to simply merging in the functionality of DebugView) I went straight ahead and converted the API to Delphi.

This should work with Delphi 6 and later. I successfully tested with Delphi 2007, 2009 and 2010.

(Update: the originally posted version did actually not work with Delphi 2007 or earlier because I had inexplicably overlooked “that Unicode thing”… Thanks to GunSmoker for pointing that out! Using $ifdef UNICODE and WideString is a cheap cop-out, I know – but it works)

Enjoy:

unit ProcMonDebugOutput;

interface

uses
  Windows;

type
  TProcessMonitorLogger = class
  private
    const
//      FILE_WRITE_ACCESS           = $00000002;
//      METHOD_BUFFERED             = $00000000;
//      FILE_DEVICE_PROCMON_LOG     = $00009535;
//      IOCTL_EXTERNAL_LOG_DEBUGOUT = CTL_CODE(FILE_DEVICE_PROCMON_LOG,
//                                             $81,
//                                             METHOD_BUFFERED,
//                                             FILE_WRITE_ACCESS);
      IOCTL_EXTERNAL_LOG_DEBUGOUT = $95358204;
    class var
      FDevice: THandle; // = INVALID_HANDLE_VALUE
    class function Open(): THandle;
    class procedure Close();
    {$IF CompilerVersion >= 21}
    class constructor Create;
    class destructor Destroy;
    {$IFEND}
  public
    class function Output(const AOutputString: {$ifdef UNICODE}String{$else}WideString{$endif}): Boolean;
  end;
  PML = TProcessMonitorLogger;

implementation

{ TProcessMonitorLogger }

//function CTL_CODE(const ADevType, AFunc, AMethod, AAccess: Cardinal): Cardinal; inline;
//begin
//  Result := (ADevType shl 16) or (AAccess shl 14) or (AFunc shl 2) or AMethod;
//end;

{$IF CompilerVersion >= 21}
class constructor TProcessMonitorLogger.Create;
begin
  FDevice := INVALID_HANDLE_VALUE;
end;

class destructor TProcessMonitorLogger.Destroy;
begin
  Close();
end;
{$IFEND}

class procedure TProcessMonitorLogger.Close;
begin
  if INVALID_HANDLE_VALUE <> FDevice then
    begin
      CloseHandle(FDevice);
      FDevice := INVALID_HANDLE_VALUE;
    end;
end;

class function TProcessMonitorLogger.Open(): THandle;
begin
  if INVALID_HANDLE_VALUE = FDevice then
    FDevice := CreateFile('\\.\Global\ProcmonDebugLogger',
                            GENERIC_READ or GENERIC_WRITE,
                            FILE_SHARE_READ or FILE_SHARE_WRITE or FILE_SHARE_DELETE,
                            nil,
                            OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL,
                            0);
  Result := FDevice;
end;

class function TProcessMonitorLogger.Output(const AOutputString: {$ifdef UNICODE}String{$else}WideString{$endif}): Boolean;
var
  lProcMonHwnd: THandle;
  lInputLength: Cardinal;
  lOutputLength: Cardinal;
  lLastError: Cardinal;
begin
  Result := False;
  if AOutputString = '' then
    SetLastError(ERROR_INVALID_PARAMETER)
  else
    begin
      lProcMonHwnd := Open();
      if lProcMonHwnd <> INVALID_HANDLE_VALUE then
        begin
          lInputLength := Length(AOutputString) * SizeOf(WideChar);
          lOutputLength := 0;
          Result := DeviceIoControl(lProcMonHwnd,
                                    IOCTL_EXTERNAL_LOG_DEBUGOUT,
                                    PWideChar(AOutputString),
                                    lInputLength,
                                    nil,
                                    0,
                                    lOutputLength,
                                    nil);
          if not Result then
            begin
              lLastError := GetLastError();
              if lLastError = ERROR_INVALID_PARAMETER then
                SetLastError(ERROR_WRITE_FAULT);
            end;
        end
      else
        SetLastError(ERROR_BAD_DRIVER);
    end;
end;

{$IF CompilerVersion < 21}
initialization
  TProcessMonitorLogger.FDevice := INVALID_HANDLE_VALUE;
finalization
  TProcessMonitorLogger.Close();
{$IFEND}
end.

Usage:

uses
  ProcMonDebugOutput;
begin
  PML.Output('How hard could it be?');
end;

Office determines what addins to load by looking at the entries below the following two registry keys:

[HKEY_LOCAL_MACHINE\Software\Microsoft\Office\OfficeApp\Addins]

[HKEY_CURRENT_USER\Software\Microsoft\Office\OfficeApp\Addins]

(where OfficeApp should be replaced with Outlook, Word, Excel, etc.)

The sub-entries will be named after the addin’s ProgID, e.g. “Microsoft.VbaAddinForOutlook.1” is one included by default with most versions of Office. From the name it should typically be fairly obvious which entry belongs to the particular addin that you’re after. For the purpose discussed here it is irrelevant what values these sub-entries actually contain.

As you may have guessed the entries under HKLM define which addins get loaded for all users while the entries under HKCU define the ones that should be loaded for that user only. Thus, in order to change an addin’s load behaviour from “all users” to “some users” all you have to do is essentially move the relevant entry from HKLM to HKCU, e.g. by exporting the entry into a .reg-file and then deleting it, then using notepad to change the hive to HKEY_CURRENT_USER and finally re-import that .reg-file again for the users that should use the addin (or just use a group policy object). Remember that you will have to repeat this whenever you install an update of the addin in question as that will probably rewrite the entry under HKLM.

More details about addin registration from a developer’s point of view can be found on MSDN:

Registry Entries for Application-Level Add-ins
(You can disregard the note about registration for all users being ignored in that article as that only applies to VSTO-addins, not to COM-addins)

First off, I was pleased to see that attendance was definitely better than last year (where David I’s opening keynote was seen by about 30 people tops), though that might in part have been caused by the unfortunate hotel situation back then. I haven’t heard of any definite numbers yet but my personal estimation would be that there were slightly more than a hundred people this year (which is of course still way below the numbers of a few years back). During the opening’s obligatory hand-raising segment only two or three people indicated they were there for the very first time. A harsh contrast to the results of the Delphi Tage event earlier this year where about a third of the audience outed themselves as first-timers.

A welcome gimmick (for me at least) was an offer for returning attendees of the conference to get a “free” netbook. Though I have to strongly object to the “free” part of the campaign (you had to waive the usual “early bird” rebates when claiming it, so effectively you paid more than you otherwise would have), this worked out really well for me as I did not own such a thing so far and it worked fine right out of the box.

Another small thing that I found very nice compared to previous years was that in all conference rooms you were able to sit at an actual table (well, except for when they underestimated the attendance and had to bring in extra chairs which happened to me two or three times), which is not only more comfortable because of the additional leg space but also makes taking notes so much easier.

Sessions

As in most years I got to see some exceptional talks. Here are some of the ones that stood out for me:

Hadi on Test Driven Design

This was a real eye-opener on many levels while being at the same time very entertaining and thorough. I especially appreciated how Hadi took the time to present the entire thought process behind the concept but doing so in a very subtle way that made it feel very natural how all the bits fell into place.

Another very memorable bit of this talk was something that Hadi essentially tacked on at the end in response to a question from the audience: It was a one-liner for a .NET mocking framework that essentially returned a dynamically created (mock) object that implemented a given interface… it took a couple of seconds to sink in for me… this is just a little bit mind-bending if you really think about it. I want this in Delphi Win32! Now with the revived RTTI support in Delphi 2010 I think we’re already heading in the right direction that will eventually lead towards such functionality.

Ray‘s keynote on Effective UI Design

I think every developer should go see this talk at least once (I think I’ve seen it three times now in various incarnations and it just keeps getting better). This time Ray also included some (IMHO) very valid concerns about recent changes in the Delphi IDE, especially the Options dialogs. I couldn’t agree more.

Daniel (M) on advanced Debugging techniques

Even though this was already a highly informative and entertaining talk in its own right this would already have been worth it just for showing SafeMM alone! You should check it out, too: It’s a special-purpose memory manager created used by the CodeGear debugger team (thanks Chris for the clarification) to catch improper memory access directly where it happens rather than having to wait for the symptoms of such mistakes. If I understood Daniel correctly it’s a branch of FastMM.

Olaf on the new RTTI system

Can’t wait to get my hands on Delphi 2010 after this talk even though I had seen some of the new stuff at CodeRage already. This is a major milestone!

Jim and Sebastian on AOP using Delphi Prism (actually two individual talks)

This is a really new and intriguing concept and a great approach for separating concerns and getting rid of repetitive code without actually hiding it. The whole “Unquote” thing remains a bit of a mystery, though even after having seen both talks. I guess it’ll probably become clearer as you actually write aspects yourself.
Can’t wait to have aspects in Win32 even though I can well imagine that it will be some time before we see this as it will need really deep compiler support and I know what I would like the CodeGear compiler guys to focus on first instead (hint: there will be a 64-bit edition of Office 2010).

Marco and Daniel on developing for Windows 7 (two individual talks)

Not really a lot of new things if one has been following the blogosphere and played around with Seven oneself already but still very informative and well-presented. I can also now say that I was there as it happened…

Closure

A couple of last things I’m afraid I will have to get off my chest:

I was a bit underwhelmed if not even a little disappointed with the presence and (perceived) involvement of Embarcadero Germany as compared to past conferences(!), especially considering that they were again the Gold Sponsor of this conference: Their booth (which was pretty much hidden away behind a pillar) in the expo area was empty whenever I checked. They also didn’t advertise any conference rebates or raffle prizes as was customary in past years (though this post (in German) seems to suggest that a rebate offer might still be forthcoming by email).

Another slightly unnerving thing for me was that the conference IMHO missed a proper sense of closure: The agenda did not contain a closing session to boot. After the last session the conference was simply over. I could do without the endless raffle drawing of past years (even though one is of course always secretly hoping against hope to win something worthwhile) but I would have preferred at least to see the conference end with a speaker panel and a closing statement from representatives of CodeGear and Software&Support like there always was in past years. I might only be projecting my own feelings at others but I was under the impression that I was not the only one who felt a little bit “ordered but uncollected” (as we say in German) while we were standing in the lobby realizing that this was it and we could go home now.
Before anyone mentions it: there actually was a spontaneously(!) held raffle drawing but it started the very minute that the last sessions were scheduled to end (and we all know that speakers never exceed their time slots, don’t we) and lasted for about 15 minutes. By the time that I came out of the last session it was already over.

Anyway, I am very much looking forward to EKON 14 and other community events that will hopefully be happening during the next 12 months. See you there!

1. Click “immediate purchase”
2. Click “Europe”
3. In the “Germany” section, click “Find an International Distribution Partner”
4. In the “By country” section, drop down the selection list
5. scroll down
6. select “Germany” (again! – see 3.)
7. Click “Submit”
8. Select one out of 32 arbitrary vendors from the Partner Directory (and be sure to click the link in the right hand column as otherwise you will have to click once more to actually get to the vendor’s page), many of which do not even appear to have an online shop at all as far as I can tell… Most do not even mention Delphi or RAD Studio on the front page.
9. If you took a lucky guess in the previous step the vendor will have a direct link to the Delphi product page on its front page. If so, click it. Otherwise take however many clicks it takes you on that vendor’s page to select Delphi (again! – see 1.) from the product catalog.
10. Click through to the page with the pricing information only to find out that, as usual, there is a whopping 43% premium for European customers on the Pro upgrade ESD!

So much for “immediate purchase”…

In the words of Donna Noble: You’ve got to be kidding me!

That said, Delphi 2010 does still look like a worthwhile point upgrade from a technical POV… My sincerest kudos to the R&D team!

Using the code ADX-VCLSTD30 you can order Add-in Express 2009 for Office and VCL Standard at a 30% discount. The code is valid until 10 July 2009. Note that you can upgrade from this discounted Standard version to Professional or Premium for the respective price difference between Standard and Professional or Standard and Premium. Also note that even if you make use of the discount you will still have an unconditional 30 day money-back guarantee.

For the differences between Standard, Pro and Premium please refer to the Feature Matrix.

If 30% on the Standard version is not enough for you, I’d like to direct your eyes in the general direction of their discounts and special offers page. There should be something for anyone there, really.

And so the circle closes… a similar offering was also how I first heard about Add-in-Express almost exactly two years ago.

In case you’re wondering: Add-in Express is a VCL framework for true RAD-development of all kinds of Office addins (besides advanced Outlook addins you can also create addins for all other Office products as well as SmartTags and Excel RTD Servers) with special focus on seamless integration with the Office GUI. This allows you to really concentrate on the essential functionality of your addin right from the get-go rather than wasting days or weeks on tasks like trying to get a simple commandbar button to work across all Office versions.

P.S. : As I continue producing flash videos about Outlook addin-development I will eventually cover Add-in Express as well. In the meantime, you can take a look at their own Screencasts.

Here’s a commented list of links that accumulated during the preparation for my talk on developing Outlook-addins with Delphi at last weekend’s Delphi-Tage event in Hamburg (also containing some information that I did not end up covering for various reasons):

Official API-References and related Information:

• Outlook Object Model Reference:
  http://msdn.microsoft.com/en-us/library/bb176619.aspx
• Extended MAPI Reference:
  http://msdn.microsoft.com/en-us/library/cc765775.aspx
• Security Notes for Outlook Developers:
  http://msdn.microsoft.com/en-us/library/aa211242.aspx
  (detailed description of Outlook 2003’s security model from a developer’s point of view)
• Code Security Changes in Outlook 2007:
  http://msdn.microsoft.com/en-us/library/bb226709.aspx
  (among other things contains a complete list of all properties and objects protected by the Outlook Object Model Guard)
• Outlook Developer Portal:
  http://msdn.microsoft.com/en-us/office/aa905455(en-us).aspx

Source code, Tutorials and Example-Addins:

• Extended MAPI-Headers for Delphi:
  http://dimastr.com/outspy/download/MAPI_headers.zip
  (indispensable for any kind of Extended MAPI development, also when combined with Redemption – see below)
• BabelFish for Outlook:
  http://dimastr.com/babelfish/
  (the required target WebService is no longer online but the source code of this addin works very well as a starting point for new addins)
• Trust Filter for MS Outlook:
  http://www.benziegler.com/TrustFilter/
  (a non-trivial Outlook-Addin with freely available source code, written in Delphi)
• OutlookCode.com – Developer Learning Center for Microsoft Outlook
  http://outlookcode.com
  (Heaps of examples, articles, tutorials, links, etc. – mostly VB(A/S) or C# rather than Delphi, though)
• Slipstick.com – Outlook & Exchange Solutions Center
  http://slipstick.com
  (the definitive information portal for all things Outlook and Exchange)

Products presented or used:

• Add-in Express:
  http://add-in-express.com
  (Framework for true RAD-development of addins for Office, especially helps with integrating seamlessly with the Office-UI, Shareware)
• Redemption:
  http://dimastr.com/redemption
  (COM utility library written in Delphi that massively simplifies working with Extended MAPI and which thus bypasses security prompts in older versions of Outlook or when accessing Outlook from anything other than a COM-addin, Shareware)
• OutlookSpy:
  http://dimastr.com/outspy
  (Developer-utility for live-inspection and manipulation of all relevant Outlook-APIs, written in Delphi, Shareware)
• GExperts:
  http://www.gexperts.org/
  (really powerful plugin for the Delphi-IDE, which should need no further introduction, Open Source)
• DDevExtensions:
  http://andy.jgknet.de/blog/?page_id=10
  (another great Delphi IDE-plugin from Andreas Hausladen, Freeware)
• IDE Fix Pack:
  http://andy.jgknet.de/blog/?page_id=246
  (semi-official bugfixes for the Delphi-IDE from Andreas Hausladen, Freeware)
• MachMichAdmin (“Make me admin”):
  http://www.heise.de/software/download/machmichadmin/31780
  (Batch-file for starting applications using your own user account but with temporarily applied admin privileges; needs some minor tweaks to work on non-German operating systems, Open Source)
• PrivBar:
  http://blogs.msdn.com/aaron_margosis/archive/2004/07/24/195350.aspx
  (Custom toolbar for Windows Explorer that indicates the permission level in effect for a given Explorer instance, Freeware)
• Launchy:
  http://www.launchy.net/
  (application quick launcher for keyboard enthusiasts, Open Source)

Miscellaneous:

(Attention! Time for a quick commercial break. )

• Lucatec GmbH:
  http://www.lucatec.de
  (my “hand that feeds”, without whom this talk wouldn’t have happened)
• Lucatec^® Mask:
  http://lucatec.net/mask/
  (our addin for automating several tasks related to the use of shared mailboxes or Public Folders in a team, Shareware)

(end of commercial break)

• techvanguards.com
  http://www.techvanguards.com/
  (extensive articles and tutorials all about COM programming with Delphi and C++-Builder by Binh Ly – a real eye-opener for anyone that has been struggling with this topic so far)

• You can use the following .reg-file to perform registration and unregistration of COM-DLLs directly from the Explorer context menu:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\dllfile\shell]
@="openas"

[HKEY_CLASSES_ROOT\dllfile\shell\Register]

[HKEY_CLASSES_ROOT\dllfile\shell\Register\command]
@="regsvr32.exe \"%1\""

[HKEY_CLASSES_ROOT\dllfile\shell\Unregister]

[HKEY_CLASSES_ROOT\dllfile\shell\Unregister\command]
@="regsvr32.exe /u \"%1\""

Bevor ich die Slides meines Vortrages an Daniel zur ZIPpung weitergebe, hier schon einmal meine kommentierte Liste aller Links, die ich während der Vorbereitung zusammengetragen habe (enthält auch Informationen zu  einigen aus Zeit- und anderen Gründen leider entfallenen Themen):

Offizielle API-Referenzen und Infoquellen:

• Outlook Object Model Referenz:
  http://msdn.microsoft.com/en-us/library/bb176619.aspx
• Extended MAPI Referenz:
  http://msdn.microsoft.com/en-us/library/cc765775.aspx
• Security Notes for Outlook Developers:
  http://msdn.microsoft.com/en-us/library/aa211242.aspx
  (detaillierte Beschreibung des Sicherheitsmodells von Outlook 2003 aus Entwicklersicht)
• Codesicherheitsänderungen in Outlook 2007:
  http://msdn.microsoft.com/de-de/library/bb226709.aspx
  (enthält u.a. eine vollständige Liste aller vom Outlook Object Model Guard überwachten Properties und Objekte)
• Outlook Developer Portal:
  http://msdn.microsoft.com/de-de/office/aa905455(en-us).aspx

Quellcode, Tutorials und Beispiel-Addins:

• Extended MAPI-Header für Delphi:
  http://dimastr.com/outspy/download/MAPI_headers.zip
  (unverzichtbar für jede Art von Extended MAPI-Programmierung, auch im Zusammenspiel mit Redemption – siehe weiter unten)
• BabelFish for Outlook:
  http://dimastr.com/babelfish/
  (der angesteuerte WebService ist leider nicht mehr im Betrieb, aber der Quellcode dieses Addins ist ideal als Ausgangspunkt für eigene Addins geeignet)
• Trust Filter for MS Outlook:
  http://www.benziegler.com/TrustFilter/
  (nicht-triviales, in Delphi geschriebenes Outlook-Addin mit Quellcode)
• OutlookCode.com – Developer Learning Center for Microsoft Outlook
  http://outlookcode.com
  (Unmengen von Beispielen, Erläuterungen, Tutorials, Links, etc. – meist leider eher VB(A/S) oder C# als Delphi)
• Slipstick.com – Outlook & Exchange Solutions Center
  http://slipstick.com
  (das Informationsportal schlechthin für alles, was mit Outlook und Exchange zu tun hat)

Vorgestellte bzw. verwendete Produkte und Tools:

• Add-in Express:
  http://add-in-express.com
  (Framework zur echten RAD-Entwicklung von COM-Addins für’s Office-Paket, hilft insbesondere bei der nahtlosen Integration in die Outlook-GUI, Shareware)
• Redemption:
  http://dimastr.com/redemption
  (in Delphi geschriebene COM-Bibliothek, welche den Umgang mit Extended MAPI massiv vereinfacht und auf diese Weise außerdem die lästigen Sicherheitswarnungen in älteren Outlook-Versionen umgeht, Shareware)
• OutlookSpy:
  http://dimastr.com/outspy
  (Entwickler-Utility zum Live-Inspizieren praktisch aller relevanten Outlook-APIs quasi “am lebenden Objekt”, Shareware)
• GExperts:
  http://www.gexperts.org/
  (geniales Delphi-IDE Plugin, welches hinlänglich bekannt sein sollte, Open Source)
• DDevExtensions:
  http://andy.jgknet.de/blog/?page_id=10
  (noch ein geniales Delphi-IDE-Plugin, von Andreas Hausladen, Freeware)
• IDE Fix Pack:
  http://andy.jgknet.de/blog/?page_id=246
  (semi-offizielle Bugfixes für die Delphi-IDE von Andreas Hausladen, Freeware)
• MachMichAdmin:
  http://www.heise.de/software/download/machmichadmin/31780
  (Batch-Datei zum Starten von Anwendungen unter dem eigenen Benutzerkonto aber mit vorübergehenden administrativen Rechten, Open Source)
• PrivBar:
  http://blogs.msdn.com/aaron_margosis/archive/2004/07/24/195350.aspx
  (Info-Toolbar für den Windows Explorer, welche anzeigt, mit welchem Berechtigungslevel eine Explorer-Instanz gerade läuft, Freeware)
• Launchy:
  http://www.launchy.net/
  (Programm-Schnellstarter für Keyboard-Fetischisten, Open Source)

Verschiedenes:

(Achtung! Kurze Werbeunterbrechung. )

• Lucatec GmbH:
  http://www.lucatec.de
  (mein Brötchengeber, ohne den mein Vortrag gar nicht möglich gewesen wäre)
• Lucatec^® Mask:
  http://lucatec.net/mask/
  (mein “Baby” : ein Addin zum Automatisieren verschiedenster Arbeitsschritte bei der (Team-)Arbeit mit gemeinsam genutzten Postfächern oder Öffentlichen Ordnern, Shareware)

(Werbung Ende)

• techvanguards.com
  http://www.techvanguards.com/
  (Ausführliche Artikel und Tutorials rund ums Thema COM mit Delphi und C++-Builder von Binh Ly – ein echter Augenöffner, für alle, die sich bisher mit dem Thema nur gequält haben)

• Die folgende einfache .reg-Datei könnt Ihr verwenden, um die (De-)Registrierung von DLLs einfach über das Explorer-Kontextmenü durchzuführen:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\dllfile\shell]
@="openas"

[HKEY_CLASSES_ROOT\dllfile\shell\Register]

[HKEY_CLASSES_ROOT\dllfile\shell\Register\command]
@="regsvr32.exe \"%1\""

[HKEY_CLASSES_ROOT\dllfile\shell\Unregister]

[HKEY_CLASSES_ROOT\dllfile\shell\Unregister\command]
@="regsvr32.exe /u \"%1\""

So, I am back from this year’s Delphi-Tage (“Delphi Days”) in Hamburg and had a little time to let the impressions sink in a little. As has been mentioned by many participants, the uniqueness of the venue will be hard to top for future events (but then, why should it have to? – after all, it’s the overall-experience, the people, the sessions and of course Delphi that should be the main attraction, shouldn’t it?)

This year's venue - The Cap San Diego

Audience at David I's Keynote

(more pictures can be found in the coresponding  album on the DelphiPraxis forum, as well as on the Delphi-Treff site)

A big praise to Daniel Wolf for organizing the “pre-con” barbecue at “cult” football club FC St. Pauli’s where we met in a nice setting with great food and a couple of nice cold beers where you could also chat pleasantly about non-programming, non-Delphi-related topics for a change, all in the middle of the vibrant (German part of the) Delphi community.

The main event started on Saturday morning. Attendance was pretty high (over 250 people, including speakers and exhibitors, if I overheard that correctly). I was especially pleased to see so many “out” themselves as first-timers during the hand-raising section at the conclusion of the event. And the average age of the audience was also way lower than I have seen at similar events in the past which can only be a good sign, right?

David I’s keynote offered little new to anyone who had been following the coverage of last month’s  Delphi Live! conference in San Jose. It’s nevertheless always a joy to see and hear David talking. You just totally get that there is someone who’s truly got his heart in what he’s saying.

After a quick break started the first round of sessions, whereas I myself unfortunately wasn’t able to see a lot of it as I had to leave during the coffee break to find a less pricey parking space for my car and only returned (quite out of breath and sweating) for the second half of Jeroen Pluimers‘ very hands-on talk about IDE-addins and other useful tips for increasing developer productivity. Though, as at that point the room was so full that I had to stand in the doorway to the adjoining second session room, where Bernd Ott was doing an equally interesting talk about Subversion I was only able to watch and listen with half an ear and eye.

Bernd Ua - Softwaretests

After that I went to see Bernd Ua’s talk about software testing and DUnit which I watched from quite an unusual viewpoint (see picture to the left). In the meantime the time for my own talk was rapidly approaching and as this was going to be the first of its kind since almost exactly 9 years to the day (minus a month), my tension was rising considerably. As a result I could unfortunately only watch the first half of Daniel Wischnewski’s entertaining talk about the  Windows 7 Taskbar as at that point I had to step out for a quick breath of fresh air.

My own talk then was a bit of a mixed bag: While I did manage to shed most of the nervousness and was able to answer all questions from the audience, I feel that in hindsight I probably made some less than ideal decisions about weighting the individual parts of the talk in an effort to get everything in there that I had announced I would cover. Sadly, time ran out on me even before I got to the concluding segment about Extended MAPI and Redemption so I could only hasten through the slides about those topics rather than actually show some practical examples.

Well, one should learn from one’s mistakes. I will try to cover the bits that got a bit of a short end here on the blog in the form of more videos and also to do better at the next live talk. I hope everyone was still able to take away something interesting for him or herself. Please feel free to post any unasked questions here on the comment thread.

One note to the organization team regarding breaks: Please make sure that next time there will always be at least 10 minutes between sessions. That way people will actually have some time to get from one session to the next if it is in a different room than the previous one and also to step out to catch some fresh air or for taking last break’s coffee to the pottery department and so on. Furthermore, as a speaker you typically also need a couple of moments before you have got all the wiring in place and your notebook booted up properly. As most speakers (including my predecessor and me) made use of their time slot to the very last second that set-up time had to count against the regular session time while all the while the audience was already champing at the bit.

The day’s finale in the Gröninger Brauhaus was quite pleasant and fun. In my mind the pub/restaurant visit at the end has really become a stock item of the Delphi Tage events in its own right.

The first thing I found in my inbox when I turned on my computer for the first time since my return was a belated (actually, it had arrived a mere 30 minutes after I had left for Hamburg) email from the Add-in-Express team, containing a 30% rebate coupon for the attendees of my talk. I will make sure to include that in my slides before I send them off. Speaking of which, the slides of the entire event (including mine) will shortly be made available  via the DelphiPraxis forum as one big downloadable ZIP-archive. I will post the link here once it is available.

[please see next post for an English version of this article]

So, nun bin auch ich zurück von den diesjährigen Delphi-Tagen in Hamburg und hatte ein wenig Zeit, die Eindrücke auf mich wirken zu lassen. Wie schon vielfach erwähnt, wird sich die Ausgefallenheit der Location wohl nur noch schwer übertreffen lassen (muss ja aber auch gar nicht – schließlich soll ja das Gesamterlebnis, die Leute, die Vorträge und nicht zuletzt Delphi im Vordergrund stehen).

Der Veranstaltungsort - Die Cap San Diego

Publikum bei David's Keynote

(weitere Bilder gibt es übrigens im entsprechenden Album der DelphiPraxis, sowie beim Delphi-Treff)

Großes Lob an Daniel auch für die Organisation des “pre-Con” Grillabends im Clubheim des FC St. Pauli wo man sich in netter Atmosphäre, mit leckerem Essen und einem schönen kühlen hanseatischen Bier unter die Delphi-Community mischen konnte, und dabei auch mal über andere Dinge, als nur Programmieren und Delphi reden konnte.

Weiter ging es am Samstag Morgen. Die Veranstaltung war sehr gut besucht (ca. 250 Leute einschließlich Speaker und Aussteller, wenn ich Daniel richtig verstanden habe). Besonders erfreulich fand ich auch die besonders große Anzahl von Leuten, die sich bei der abschließenden “Hände-heben”-Runde als Erstbesucher “geoutet” haben. Der Altersdurchschnitt lag meinem Empfinden nach auch etwas niederiger als bei früheren Events, was ja nur ein gutes Zeichen sein kann.

Die Keynote von David I bot wenig Neues, sofern man die Berichterstattung zur Delphi Live!-Konferenz im letzten Monat verfolgt hatte. Trotzdem finde ich es immer wieder erfrischend, David reden zu hören. Man merkt einfach, dass er mit Leib und Seele bei der Sache ist.

Weiter ging es mit den ersten Runde Sessions, wobei ich davon selbst leider nicht mehr viel mitbekommen habe, da ich die Kaffeepause nutzten musste, um einen kostengünstigeren Parkplatz für meinen Smart zu suchen. Zumindest die letzte Hälfte von Jeroens Vortrag über IDE-Addins und sonstige nützliche Tipps zur Produktivitätssteigerung konnte ich noch mit halben Ohr und Auge verfolgen – leider war der Raum so voll, dass ich nur im Durchgang zum Nebenraum stehen konnte, wo Bernd Ott einen ebenfalls sehr interessanten Vortrag zum Thema Subversion hielt.

Bernd Ua - Softwaretests

Danach ging es für mich ohne Pause weiter mit Bernd Uas Vortrag zu Softwaretests und DUnit, welchen ich aus ungewohnt luftiger Höhe verfolgt habe… (siehe Bild links).

In der Zwischenzeit rückte mein eigener Vortrag immer näher und da dies der erste seit fast auf den Tag genau 9 Jahren sein sollte (abzgl. einem Monat), stieg die Anspannung bei mir entsprechend. Sakuras Vortrag über die Windows 7 Taskbar konnte ich leider entsprechend auch nur zur Hälfte verfolgen, da ich erst noch ein wenig Frischluft schnappen musste.

Mein eigener Vortrag schließlich war eine gemischte Angelenheit: Zwar konnte ich meine Nervosität größtenteils noch ablegen und konnte auch alle Zwischenfragen beantworten, aber meine Entscheidungen zur Zeitaufteilung und Gewichtung  der einzelnen Vortragsteile waren, im Nachhinein betrachtet, glaube ich nicht ganz ideal und obendrein reichte die Zeit leider gar nicht mehr für den abschließenden Teil zum Thema Extended MAPI und Redemption, wodurch ich zu diesem Thema nur noch im Eiltempo die Slides durchklicken konnte, anstatt echte Praxisbeispiele zu zeigen.

Nun ja, wie sagt man: aus Fehlern lernt man. Ich werde versuchen, die zu kurz gekommenen Teile hier in Blog- und Videoform nachzureichen und es beim nächsten Live-Vortrag besser zu machen. Ich hoffe, es konnten trotzdem alle Anwesenden das eine oder andere für sich mitnehmen. Konkrete Fragen beantworte ich auch gerne hier im Kommentar-Thread.

In Sachen Pausen nochmal eine kleine Anmerkung für die Organisatoren: Bitte beim nächsten Mal auch zwischen den Vor- und Nachmittagssessions noch 10-15 Minuten Pause lassen, so dass die Teilnehmer auch Zeit haben, von einer Session zur nächsten zu laufen, nochmal (eine Stange) Frische Luft zu schnappen, die Getränke aus der letzten Pause in die Keramikabteilung zu tragen und so weiter. Außerdem braucht man ja auch als Speaker noch einen kurzen Moment, bevor man sein Notebook ordnungsgemäß verkabelt und hochgefahren hat. Da die meisten Speaker, so wie auch mein Vorredner und ich, ihre Zeit (mehr als) voll ausgenutzt haben, mussten diese Vorarbeiten dann alle schon während der eigentlichen Session-Zeit erledigt werden, während das Publikum schon mit den Füßen scharrte…

Den Ausklang des Tages im Gröninger Brauhaus fand ich schließlich auch sehr amüsant und gesellig (ich sag nur: “JUUUUNGS!!!” ). Das gehört für mich mittlerweile auch einfach zu den Delphi-Tagen dazu.

Das erste, was ich schließlich heute morgen in meinem Posteingang fand, war ein 30%-Gutscheincode, welchen mir das Add-in-Express-Team etwas verspätet (um genau zu sein: 30 Minuten nach meiner Abreise am Freitag) für die Teilnehmer meines Vortrages zugesandt hatte. Ich werde diesen auf jeden Fall noch mit in die Slides einbauen, bevor ich Sie verfügbar mache.

Apropos, die Slides der gesamten Veranstaltung, einschließlich meiner, wird es in Kürze über die DelphiPraxis als großes ZIP-Archiv zum Download geben. Ich werde den entsprechenden Link dann auch noch einmal hier posten.

So, here’s the second example on creating Outlook-Addins with Delphi which will likely not be included in my talk at the German Delphi-Tage due to time constraints.

In this one I show how to add an option page to your addin, which is typically used for letting the user configure your addin or for displaying version and contact information.

Again, raw and unedited (I’m probably talking too fast in this one). Recorded at 1024×768 in English, 9 minutes and 28 seconds.

Enjoy.

[Part 1]

This is raw and unedited and I assume prior knowledge of some COM-basics and terminology like CoClasses, ProgIDs and type libraries and how to create and register COM-DLLs.

This was recorded at 1024×768 in English language (while the live talk will be in German) and is 7 minutes 29 seconds long.

Enjoy!

[Part 2] Option Pages

https://ogware.wordpress.com

The preferred method to subscribe to the new blog is via FeedBurner from the following link:

Subscribe in a reader

Hopefully there’ll also be a slew of new content coming “really soon now” (keeping fingers crossed) as I get ready for my talk about Outlook Addin Development at the Delphi Tage event this weekend in Hamburg.

Signing out… (from LiveJournal)

I’ve had my first close encounter with the customer support of a certain big software vendor which I’ll try my best not to name here. Let’s say we have a product that works closely together with one of theirs and because of that some of our customers notified us of a problem that after close examination turned out to be what I’m currently certain is a bug in that vendor’s piece of software. One of their recent updates introduced a significant change in behaviour in a somewhat obscure area that just couldn’t have been on purpose (it’s also mentioned nowhere in the release notes). As that particular obscure area also touches on the correct functioning of our own tool we had an increased interest in getting this sorted out.

As that company does no longer have a public bug tracker (“because 90% of the filed items were really just requests for free tech support”) the only way to notify them of bugs in their products nowadays is by opening a regular support case — at the risk of having to pay for the tech support in case the tech handling the case determines that the problem was on our end after all. So, with that in mind, I wanted to make extra sure that I knew as much as possible about the issue (and especially how to trigger it) before I contacted them. I set up a test system with nothing but the supposedly defective software on it in a virtual machine and tried to reproduce and analyze the issue as best as I could. Once I was sure I knew what to do to reliably provoke the issue I phoned the first screener. That is, I phoned the first level support who noted down my data and a rough description of the problem, gave me a case number and told me that I would be contacted by a tech within 4 business hours. All fine. The call even came less than an hour later.

I first started to explain the problem again but the helpful support person quickly suggested we do a remote access session so he could see the issue first hand on my machine. All the better I thought, shared my desktop with the VM on it and Bob’s your uncle. Well, no. Not really. After having spent three days investigating, discussing with several unrelated affected customers, analyzing, probing, diagnosing, testing and consistently provoking the issue – all of a sudden the issue no longer occurred! No way, everything just worked as it was supposed to. It hadn’t been five minutes since I ran my last batch of tests where each and every single attempt succeeded in making visible the issue we were dealing with. And now – nothing to show. Quite embarrassing. I was completely dumbfounded. As the issue could no longer be reproduced at the time of first contact, the nice support person kindly offered to close the case for free. If I managed to reliably reproduce the issue again I could still contact them again and have the case reopened but in that case I better had something to show.

Needless to say, less than five minutes after hanging up I was able to reproduce the issue again – and again – and again. Not quite as reliably as before the call but still quite definitely there. I started to remember that in the release notes for the update that introduced the issue it was mentioned that several operations that were previously carried out sequentially had now been parallelized or moved to background threads in order to improve performance and responsiveness of the app. OK, so timing obviously plays a role here as well – and that could well be affected by a remote support software hooking into the video driver – we had a similar case ourselves a mere three months earlier.

Once I had been able to trigger the issue again after the call I installed Camtasia into the VM and began stress testing for good. At first I only managed to reproduce the issue about 4 out of 30 times but soon I was getting better. Apparently the issue was more likely to happen right after the app had been restarted. Most importantly, I finally had the bugger on camera. I trimmed  the video and sent it to the support people – and waited.

Today, less than two hours before closing time I sent another reminder, asking for confirmation that the case had been reopened. I quickly received a response that they were still checking whether the video would actually suffice for “producing evidence”. I was also told that it would probably be better if I was able to reproduce the issue in a really clean environment without any other software involved at all (keep this snippet in mind for later).

I just as quickly replied back pointing out that the only other software installed on the machine where the video was produced was Camtasia and anyway, we could simply do another remote access session and just try a little harder to trigger the issue this time – after all, when we tried it the last time I fully expected the issue to occur on each and every try so when it didn’t, we immediately aborted the whole show. I also reported that by now I was able to reproduce the issue in my test environment in more than 20 out of 30 cases. I also inquired (and neither for the first nor the last time during that exchange) whether there was some kind of diagnostic logging I could turn on or whether sending the produced output files (which exhibited the error) would help.

No direct reply to any of those offers and questions. What I did get was a message that they had now at last watched the video I sent and that they would reopen the case – but in that case all further reproduction tests should be workable in a non-virtualized environment. Sure, no big deal, we have lots of unused physical boxes lying around here that could be prepared for this (remember: “ideally without any other software involved at all”), not to speak of the limitless amounts of time on our hands – not!

After my somewhat snappy and already more than slightly annoyed response the phone was quickly ringing again. The case had now been officially reopened and we started noting down the specs of the test environment (OS and program versions, network setup, etc.), possibly in preparation for another, more in depth analysis session. Somewhere in the middle of all that came the sentence “well, we do not support test systems really” and then “we’d prefer to see the issue reproduced on a live production system”… WTF?!?!?!

“Yes, just imagine we fix that issue in your test environment and then you take the fix to the production environment and it fails again.”

Um, I don’t know about you but the first thing I do when I’m hunting down a bug in my own programs is to eliminate outside factors to the point where I have distilled the exact minimum set of factors that are responsible for causing the bug. The last thing I would want to do is maximize the number of outside factors as was being proposed here.

At that point I realized that what the friendly tech guy was doing had nothing at all to do with trying to find the bug. He was still trying to prove (or rather make me admit) that there was no bug in the first place! After having supposedly watched the video of the bug happening! This was probably just the second screener that I had to get past before someone actually started taking me seriously and finally looked into the issue. I’m fully convinced that noone there has taken any steps to try and reproduce or otherwise investigate the issue themselves so far.

Did I mention that at that time I was able to reproduce the issue with something approaching 95% certainty in the test environment again?

Right, so if that’s the way they want it… I agreed to contact some of the affected customers and ask them for participation in “producing evidence” (I guess I should mention that we are not using the affected version of the software in production ourselves).

So I called one of the customers who immediately agreed to assist. As I had tentatively scheduled the remote access session for after the weekend I wanted to “rehearse” the whole thing to be on the slightly safer side this time and connected to the customer (who also consistently experienced the issue ever since the update). Guess what? Yep, no longer reproducible on that box as well as soon as I started watching… then again, we only tried three or four times because it was already late.

What a way to leave for the weekend…

And yes, as you can probably tell, I am so looking forward to Monday…

(to be continued)

I have installed Delphi 2009 Professional myself on two different machines now. A co-worker did the same on his own machine. On all three machines the main install was not successful initially, failing to install the "dbpack" component for some unexplained reason. Also, after the main installer was finished all three machines rebooted without warning or a prompt to delay the reboot. All open apps were simply terminated hard as soon as I hit the Finish button and Windows went into shutdown.

After the reboot I manually installed the dbpack as recommended in the preceding error message. This worked flawlessly. On my home machine I had to reboot again after this was done. At least this time it gave me a chance to first save my work and reboot when I was ready.

Help installation took a while longer than the main installer but otherwise also worked flawlessly. Online registration also was no problem on all three machines using existing CDN account data.

Checking for and installing the updates did not work out of the box on the two machines here at work, both failing with exactly the same symptoms. Strangely enough after having correctly identified the available Update 1 and downloading it the update installer aborted with an error from the 16-bit MS-DOS subsystem (huh?) and then hung itself. After I terminated it any attempt to check for updates always resulted in the message that no updates were available. Running the downloadable Update 1 installer from the registered users page however worked flawlessly again.

I don’t remember having had any such problems when I installed the trial version a month ago – well, except that I couldn’t install the Update 1 – but I think that was by design as it only appears to be available to registered users.

cvsnt-2.5.3.2260-setup.zip (3.706 KB)

Note that this installer is not yet 64bit-enabled (whereas the original MSI installer is) as I did not have time yet to look into the requirements for making it so (not to mention that I am lacking the test environment). I will update this entry (or post a new one) once I have gotten round to that.

See my previous announcement for a short summary of what’s different with regards to the official MSI installer. I also took the opportunity to add a “Server only installation” install type in addition to the “Client only installation” one I added some releases ago which is also not available in the MSI installer. I have included the install source script for InnoSetup 5.1.6 inside the download archive as well this time .

>>> Official Release Notes <<<

If you intend to use this build as a client binary for WinCvs, make sure you read my notes accompanying the original 2.5.03 release as unfortunately a minor incompatibility has crept in at that point. Said entry also describes the workaround.

Cheers,

Oliver