• what you really did (whatever it means to you);
• what opensource/published projects did you participate in;
• Top Stack questions you answered;
• your professional reading and (sic!) writing.

Here I am: http://careers.stackoverflow.com/victors
(have to complete it still)

Got 5 invites btw.
Actually, just testing a new LiveJournal crosspost plugin.

It’s not as if it was badly written or designed. But it lets you to unit-test dirtier code, tying to method call structure instead of resulting data.

For instance, this GMock code can be rewritten:

        loggingService.sendNotification(match{ !it.shouldNotify() }).stub()
        loggingService.sendNotification(match {
            it.shouldNotify() && it instanceof HubOfflineNotification && it.deadEntities == [hub]
        })
        loggingService.saveEvent(LogEventType.HUB_BECAME_OFFLINE, match { it }, customer)
        loggingService.saveEvent(LogEventType.CAMERA_DIED, match { it }, customer).never()

        play {
            loggingService.reportHealth(diff)
        }

to:

        eventLogService.reportHealthDiff(diff)

        assertEquals 1, LogEvent.countByEventType(LogEventType.AGENT_BECAME_OFFLINE)
        assertEquals 0, LogEvent.countByEventType(LogEventType.METER_BECAME_DEAD)
        assertEquals 1, LogEvent.countByEventType(LogEventType.SENDING_NOTIFICATION)

which relies only to call outcome, and not to implementation details.

Just put together a Comparator for StackOverflow question – a Groovy Comparator that would sort class field names in the declaration order. Feel free to use:

class PropComparator implements Comparator {
    private Class clazz
    PropComparator(Class clazz) { this.clazz = clazz }

    int compare(Object o1, Object o2) {
        clazz.declaredFields.findIndexOf{it.name == o1}
          - clazz.declaredFields.findIndexOf{it.name == o2}
    }
}

Before, you had to use window functions rownumber() and fetch first 40 rows only. When used by Hibernate, this resulted ugliness like:

select * from (
  select inner2_.*, rownumber() over(order by order of inner2_) as rownumber_
  from (
    select  ...
    fetch first 40 rows only
    ) as inner2_
  ) as inner1_
where rownumber_ > 20
order by rownumber_

Since this summer version – DB2 9.7.2 – you can just append LIMIT and OFFSET:

SELECT ... LIMIT 5 OFFSET 10

No wrapping into 2 (!!!) external SELECTs.
One downside is that mighty DB2 does have MySQL compatibility layer mode. Turn it on when starting DB2:

$ db2set DB2_COMPATIBILITY_VECTOR=MYS
$ db2stop
$ db2start

I’m replacing a diggIt button; Buzz fits my color scheme better

Enjoy.

def c = Price.createCriteria()
c.list {
    priceProvider {
        company {
            country {
                eq('currency.id', 1L)
            }
        }
    }
    projection(
       groupProperty('id')
    )
    order('timestamp', 'desc')
}

def books = Book.findAll("FROM Book AS b JOIN Chapter AS c WHERE c.active = :isActive")

with a NullPointerException in “HqlSqlWalker.createFromJoinElement” — just use alternative join syntax, via WHERE:

def books = Book.executeQuery("select b FROM Book AS b, Chapter AS c WHERE c.active = :isActive")

Move “WITH” conditions to “WHERE” as needed.

Here’s a short list of short (though very deep, if not best) intros.

• Except for JUnit cookbook (~2 pages) (which has a lot of “ports”, like CppUnit cookbook), I’d name:
• “Endo-Testing: Unit Testing with Mock Objects” at mockobjects.com (Tim Mackinnon, Steve Freeman, Philip Craig) (7 pages);
• “Mocks aren’t stubs” by Martin Fowler (about 7 pages);

For deeper dive, take a “xUnit patterns” book (this one is longer).

For Kent Beck‘s book on TDD, shame on me – I never read it. Though after “XP explained” I don’t strive for reading his books.

// If you’re interested in XP and “XP explained” criticism, take a look at “Extreme Programming Considered Harmful for Reliable Software Development” by Gerald Keefer.

• (-4) To run tests, VS launches an entire process which takes no less then 3 seconds to start. If you’re in “F5 hit breakpoint – Shift-F5″ loop, that’s disgusting. NUnit tests can be run in-process by Resharper or TestDriver.NET;
• (-2) GUI that shows where test failed is ugly. You don’t get to failed line on double-click, you first get to test log page. Status and call stack are necessary, but I’d like not to trash my document tabs, I already have enough of them open. You can’t make that kind of windows docked/floating;
• (-1) You got a “public TestContext TestContext;” sticking in your code. You’ll need it only when it comes to testing on data, which doesn’t always happen, even in a data-driven application;
• (-1) It’s a “not invented here” technology, while NUnit was around for years;

Edit: In a moment of madness, I mixed together coverage profiling and unit testing tools. May God and readers forgive my aberration.

Edit2: If you need a half-page kickstart in unit testing techniques, the next post can help.

It’s extremely simple:

• 6 data types (that’s counting “nul” and “function”),
• no C++-style OOP out-of-box (but you can program one, he-he),
• 400K of pure-C code

but is loaded with in-fashion features like

• first-class functions,
• closures,
• coroutines…
• again, Wikipedia is the best.

The only metaprogramming tutorial (with a ready code to implement virtual methods) is “Programming in Lua” book. Still, I don’t see a code to implement ad-hoc polymorphism… Maybe it’s a reason for another post

Redistributed book removed: it violated copyright.

What if you do the same for nonvirtual function?

Here’s a test:

#include <iostream>

class A
{
  public:
  virtual void f() { std::cout << "A::f()\n"; };
  void g() { std::cout << "A::g()\n"; };
};

class B : public A
{
  public:
  virtual void f() { std::cout << "B::f()\n"; };
  void g() { std::cout << "B::g()\n"; };
};

typedef void (A::*VirtualFunctionPointer) ();

int main()
{
  A a;
  B b;
  B* pb = &b;

  VirtualFunctionPointer p = &A::f;
  (pb->*p) ();

  p = &A::g;
  (pb->*p) ();
  return 0;
}

Answer is in comments.

#include <iostream>
#include <sstream>
using namespace std;

#define SFORMAT(e) ((dynamic_cast<const ostringstream&>(ostringstream() << e)).str())

int main(int argc, char* argv[])
{
cout << SFORMAT("2 x " << " 2 = " << 2*2);
return 0;
}

No one asks you what it will print, unless you’re a god.

Question is: why is the first const char* printed as a pointer, instead of what we need?
Two years ago, I couldn’t tell.
Some guru from Apple answered this in a newsgroup.

Here, take another, simpler C++ quiz about member pointers.

1. Don’t generate files with AssemblyInfo task. It screws comments, screws InternalsVisibleTo attributes, and whatever else it doesn’t account for.
   Instead: Use
   <FileUpdate Files="@(AssemblyInfoFiles)"
Regex="AssemblyVersion\(".*?"\)\]"
ReplacementText="AssemblyVersion("$(Major).$(Minor).$(Build).$(Revision)")]"
/>
<FileUpdate Files="@(AssemblyInfoFiles)"
Regex="AssemblyFileVersion\(".*?"\)\]"
ReplacementText="AssemblyFileVersion("$(Major).$(Minor).$(Build).$(Revision)")]"
/>
2. Don’t account for TfsXXXX community tasks – it won’t run on VS 2008 with Team Explorer 9.0.
   Instead:  Use <Exec Command=”tf …”>.
   And if you have domain authentication in TFS and don’t run integration under domain user (which happens), you even can’t run tf in cmd-line mode: stupid authentication dialog will pop up.
3. Do not use local files to store version number. You will lose them when moving build to another host, so use only source control-dependent files.
   Might seem evident, but strange how many people miss this.
   So you’ll need to
   <Attrib Files="version.txt" Normal="true" />
4. Per Scott Colestock’s post, “since TfsVersion interrogates the build server’s workspace, and BuildNumberOverrideTarget comes early in the process… you might find that you don’t get the changeset number you expect”.
5. Don’t try to operate on XML node collections with tasks other then Xslt.
   For instance, XmlRead returns a Nodeset only as a string of “;”-joined
   Node.Value-s.
   XmlQuery supports Values property, though I wasn’t able to operate it’s results.
   Instead you can use ReadLinesFromFile (sadly, this will trim the lines).
   My personal choice for not-too-complex XML is… you can guess… yes, FileUpdate.
6. Don’t use FtpUpload. It won’t create folders for you.
   Just <Exec> a ftp…
   By the way, Windows’ ftp.exe client is unable to upload in passive mode. You can download passively, if you issue “LITERAL PASV“, but it won’t help the client.

If scheduling reboot after installing .NET or other prerequisites, bootstrapper copies itself to run from TEMP on boot. Why not staying where it is – who knows. And definitely, all the other MSIs are not copied, so it won’t find them. Reproduced for me.

Now give up and go write own bootstrapper. I’m setiously considering going for InnoSetup deployment.

For now, I’m trying a crazy ting, to copy MSI to TEMP for Setup.exe to find it after reincarnation… It’s the way to use given tools.

It’s Windows Installer error 1618 that I didn’t see somewhy when attempting to fix .NET bootstrapper. Either I was inattentive or it wasn’t there: “Another copy of msiexec is running”. You can’t have two Windows Installers running, at least if one of them installs .NET. Information is from this maillist post.

Why? Implementation limitations, I believe. No sane reasons for such a contract, no article mentioned this. Surely, who’s going to declare own “features” of that kind – just a gentle hints that “you should better use bootstrapper”. Another reason to long for a systems where setup is just a copy.

So go pack a MSI, then make a MSBuild bootstrapper.

Oh wait, do I have to have 2 files in my installation? And my customers can’t download one file?

Yes. Or go for WinZip Self-Extractor, or WinRar, or whatever else.

What about build scripts? For WinRar, here’s a nice sample. For WinZip sfx, there’s also a command-line interface. Do a

wzipse32 %ARC_NAME% -setup -auto -runasuser -le -i ../icon.ico -wait msiexec -c ".\setup.exe"

WinZip will do the thing, though displaying some dialogs we don’t need at all.

Oh, WinRar won’t work, because it erases temporary files upon setup.exe completion. And we need to wait for msiexec, because setup.exe exits earlier. What a pity.

Including me.

Not mentioning pain of rolling back all LINQ tasties in code and debugging our replacements (do you know why you can’t implement Where() just with yield-style function?), it means installing .NET 3.0.

It seemed to be not a problem, having a MSBuild code snippet that worked for 3.5 – just replace 3.5 with 3.0:

<ItemGroup>
<BootstrapperFile Include="Microsoft.Net.Framework.3.0">
<ProductName>.NET Framework 3.0</ProductName>
</BootstrapperFile>
<BootstrapperFile Include="Microsoft.Windows.Installer.3.1">
<ProductName>Windows Installer 3.1</ProductName>
</BootstrapperFile>

<Target Name="Bootstrapper">
<GenerateBootstrapper
ApplicationName="blah blah blah blah"
BootstrapperItems="@(BootstrapperFile)"
BootstrapperKeyFile=""
OutputPath="obj"
ComponentsLocation="HomeSite" CopyComponents="false"
SupportUrl="http://www.microsoft.com/downloads/details.aspx?familyid=10CC340B-F857-4A14-83F5-25634C3BF043"
Culture="en" Path="$(BootstrapperPath)"/>
</Target>

Won’t work.

Hell why? Who knows. Logs in temp don’t give proper diagnostics, nor system events do. WPF fails to install at some point onto every XP installations we have, including clean special test XP SP2 VMWare images downloaded from Microsoft.

Update: Here’s the answer.

Now I rolled back to dotnetfx3setup.exe redistributable. It’s 2.8M compared to 300K bootstrapper generated by MSBuild, and it’s a pain to see installer grow…And if .NET 3.0 is already installed it starts to uninstall it… and there is no key to make it just “check or install”, need to trick it via WiX.

But we have to pay it. Oh my.

All over the Web I see no evidence that any man walked this path before. For.NET 2.0 – a lot of mentions and code samples. And completely empty for .NET 3.0.

Microsoft has a static code checker tools for C++, like FxCop for .NET.

That’s awfully complex task, you now see. In .NET you can analyze bytecode, and luckily don’t really need to account for conditional compilation. In C++ where everthing is about #ifdef – it’s hell.

I never heared of anything like that. Though Insure++ or AQTime do way more things when profiling runtime, they of course find only things that were on necessary execution paths.

• WiXWiki.com – pretty useful and contains some snippets you won’t find in WiX manual or tutorial. Many of rare code snippets
• WiX development releases; some broken (last two broken in VS 2008), some contain the very things you’ll need;
• Justin Rockwood’s blog entry with Votive (Visual Studio addon) preprocessor variables. The blog itself is also thing to read;
• Alex Shevcuk’s blog entry on checking pre- and postconditions in WiX. His whole cycle on WiX – I also highly recommend it;
• Separately, .NET: WixWiki pages about checking for .NET runtime and deploying it with a bootstrapper generated with MSBuild;
• Another WiX wiki on mindcapers.net, I particularily needed ICE38 error explanation;
• John Robbins’ blog entry on patching patching with WiX. You don’t want number of auto-update patches to grow quadratically?
• Last but not the least, MSI properties reference on MSDN.

Well, I know some pieces of software that are good, but I won’t mention them today.

One of our msbuild vs nant choice criteria is  a product versioning support.

Sad or funny things are:

• both don’t include sane tool out of box;
• both need installing NAntContrib or MSBuild Community Tasks;
• even then both can’t sanely write AssemblyInfo.cs in order to leave other properties intact; if you had InternalsVisibleTo satellite unit test assembly – it won’t build then;

NAntContrib Version task is way more functional.

Additionally, MSDN page design where MSBuild reference manual lives, is awful.

I wonder if it’s the reason to choose a build tool, while they are approximately equal.

OTOH, MSBuild has a great GenerateBootstrapper task to install .NET framework from MSI (WiX sample included in the referenced wiki).

Windows Installer on itself is a pain. WiX saves you from it, mostly wrapping the complexity into XML constructs understandable to non-gurus.

Well, not completely – you still have to know:

• why the heck shortcut didn’t appear in start menu;
• how to create a web site shortcut;
• why to create RegistryValue for a program directory you create, and that’s the simplest things. Still better then MFC…

But a very good tutorial exists, maillist is very active and it’s easy to get support.
Maybe it’s another reason to love Unix-es, where “install IS just a copy”.
Though, one has to admit that installing Windows application involves somewhat more desktop integration.

I was looking for an auto-update, so that:

• application could say “New version available, download? Restart now?“;
• would use MSI;
• download should preferably use BITS.

Simple automatic updaters like this on Codeproject won’t do, because you can’t just download necessary files: Windows Installer will revert them back. Or you would have to “disable WI’s Resiliency“, which is also a bad idea.

Solution of my choice

ClickThrough subproject of WiX promises that, but it’s still beta and crashes. Still you can easily compare two MSI files, generate a MSP patch, and a RSS feed that client can check, download and even read by eye, so simple it is – a pretty tasty feature.

There is no .NET client code. For now, there is only a separate update.exe that will find, download and install new version. Still, you cannot ask user whether to download now or not, cannot tell what’s new, when to restart, etc.
But you can painlessly add a Start menu shortcut that will update your application.

Come later, I’m going to create a C# code that will check for updates, and probably publish it.

Other solutions

You can use Updater ApplicationBlock, or more exactly, latest version now lives at CodePlex. But Enterprise Library wasn’t updated for .NET 3.5, and I believe it’s abandoned.

You can use NSIS. Though, it’s not Windows Installer MSI packager, it creates own files and scripts.

For ClickOnce application, you can use Application.Deployment.