Stefan Bodewig's Weblog

Lazy Sequence of Directory Descendants in C#

Chris Sells translated a Clojure implementation of a function that descends into a directory in a "lazy" manner by Craig Andera into C# but his solution is so C# 2.0 ;-).

Here's my take

    static IEnumerable<string> GetDirectoryDescendants(string path) {
        return Directory.GetFiles(path)
            .Concat(Directory.GetDirectories(path)
                .SelectMany<string, string>(GetDirectoryDescendants)
            );
    }

where I'd hope C# 4.0's compiler will be able to deduce the types for the SelectMany itself. Interestingly the C# 3.0 compiler does fine when I use a lambda expression instead:

    static IEnumerable<string> GetDirectoryDescendants(string path) {
        return Directory.GetFiles(path)
            .Concat(Directory.GetDirectories(path)
                .SelectMany(dir => GetDirectoryDescendants(dir))
            );
    }

How to detect Ant 1.8.0 (or later)

So Apache Ant 1.8.0 is out and I'm supposed to follow a tradition I started with Ant 1.6.2. If you can be sure that you are at least using Ant 1.7.0 then the built-in <antversion> task/condition will do:

  <antversion property="Ant-1.8.0-or-later"
              atleast="1.8.0"/>

otherwise the trick of checking for a class that has been introduced with Ant 1.8.0 can always be used:

  <available property="Ant-1.8.0-or-later"
             classname="org.apache.tools.ant.types.resources.MappedResource"/>

What's New in Ant 1.8.0?

Antoine Levy-Lambert has recently built the first release candidate for Ant 1.8.0 and called for a vote, so we should be close to the first Ant release since eighteen months. This release mostly brings enhancements and bug fixes to many tasks and types (this is the real strength of Ant IMHO) but there also are a few core changes, the full list is here.

My personal top five changes (I know there are six items, but the first one doesn't count ;-):

More than 275 fixed Bugzilla issues.
Lexically scoped local properties, i.e. properties that are only defined inside a target, sequential block or similar environment. This is very useful inside of <macrodef>s where a macro can now define a temporary property that will disappear once the task has finished.
<import> can now import from any file- or URL-providing resource - this includes <javaresource>. This means <import> can read build file snippets from JARs or fixed server URLs. There are several other improvements in the area of import.
Various improvements to the directory scanning code that help with symbolic link cycles (as can be found on MacOS X Java installations for example) and improve scanning performance. For big directory trees the improvement is dramatic.
The way developers can extend Ant's property expansion algorithm has been rewritten (breaking the older API) to be easier to use a be more powerful. The whole local properties mechanism is implemented using that API and could be implemented in a separate library without changes in Ant's core. Things like the yet-to-be-released props Antlib can now provide often required "scripty" fuctions without touching Ant itself.
At the same time the if and unless attributes have been rewritten to do the expected thing if applied to a property expansion (i.e. if="${foo}" will mean "yes, do it" if ${foo} expands to true, in Ant 1.7.1 it would mean "no" unless a property named "true" existed). This adds "testing conditions" as a new use-case to property expansion.

A new top-level element <extension-point> assists in writing re-usable build files that are meant to be imported. <extension-point> has a name and a dependency-list like <target> and can be used like a <target> from the command line or a dependy-list but the importing build file can add targets to the <extension-point>'s depends list.
In Ant 1.7.1 one would use something like

imported.xml:
<project name="imported"...>
  ...
  <target name="setup">
    ...
  </target>
  <target name="compile" depends="setup">
    ...
  </target>
</project>

importing.xml
<project ...>
  ...
  <import file="imported.xml">
  <target name="setup" depends="imported.setup">
    ... stuff that should happen before compile ...
  </target>
</project>

to define a pre-compilation stage by target overriding. With some planning it can be improved to

imported.xml:
<project name="imported"...>
  ...
  <target name="setup">
    ...
  </target>
  <target name="ready-to-compile" depends="setup"/>
  <target name="compile" depends="ready-to-compile">
    ...
  </target>
</project>

importing.xml
<project ...>
  ...
  <import file="imported.xml">
  <target name="ready-to-compile" depends="imported.ready-to-compile">
    ... stuff that should happen before compile ...
  </target>
</project>

In Ant 1.8.0 one would write this as

imported.xml:
<project name="imported"...>
  ...
  <target name="setup">
    ...
  </target>
  <extension-point name="ready-to-compile" depends="setup"/>
  <target name="compile" depends="ready-to-compile">
    ...
  </target>
</project>

importing.xml
<project ...>
  ...
  <import file="imported.xml">
  <target name="pre-compile" extensionOf="ready-to-compile">
    ... stuff that should happen before compile ...
  </target>
</project>

and the pre-compile target was added to ready-to-compile dependeny-list.

extension-point and some changes in import and its new cousin include have been inspired by Easyant which can now use an un-patched version of Ant together with a custom ProjectHelper to create a build system quite different from Ant's original ideas. ProjectHelper is the mechanism that allowed me to sketch JavaFront or Nicolas Lalevée to write GroovyFront which lets you write build files in Groovy.

Uncle Stefan

When my Mum called us this morning to tell us that my brother's first daughter was born my kids celebrated "finally I'm a cousin".

Welcome Carina - being born on 11/11 will not always be easy in the rhine area - and congratulations Claudia and Maik.

PGP-Key Signing am OpenMonday der ruhrJUG am 16.3.2009

Wo	Im Wintergarten des Unperfekthaus in Essen
Wann	16. März 2009, gegen 18:30 Uhr

Nachdem es zumindest ein paar Interessierte gibt, werden wir eine "Key-Signing-Party" im Rahmen des OpenMonday einfach mal ausprobieren. Der OpenMonday ist offen für alle, somit auch das Key-Signing, allerdings kostet der Eintritt in das Unperfekthaus 5,50 € - dafür sind alkoholfreie Getränke im Eintritt enthalten.

Wie geht das?

Ziel des Ganzen ist, dass Menschen mit OpenPGP Schlüsseln sich treffen und sich gegenseitig überzeugen, die jeweiligen Inhaber(innen) ihrer Schlüssel zu sein. Später - nicht im Rahmen der "Party" - unterzeichnet jede(r) die Schlüssel, von denen sie/er überzeugt werden konnte.

Vorbereitung

Wenn Du an der "Key-Signing-Party" teilnehmen möchtest, dann schicke mir Deinen Schlüssel (den Schlüssel, nicht die ID, ich werde nicht selber auf Jagd nach Schlüsseln gehen) an keys-openmonday-20091603@stefan.samaflost.de - mehr ist nich nötig. Du solltest innerhalb weniger Tage eine Rückmeldung von mir bekommen.

Da ich noch ein wenig Vorbereitung benötigen werde, sollten die Schlüssel spätestens am 15. März angekommen sein.

Die "Party"

Ich werde eine Liste mit allen Schlüsseln, die ich bekommen habe, ausdrucken und für jeden Teilnehmer mitbringen. Diese Liste enthält die Key-IDs und Fingerprints.

Im ersten Schritt prüft jeder seinen eigenen Eintrag auf der Liste - wir wollen ja vermeiden, dass ich irgendwem meinen eigenen Schlüssel unterschiebe.

Darüber hinaus werde ich aus allen Keys einen Keyring herstellen, den ich zum Download anbiete und ggf. per Email versende (mal sehen, wie viele Teilnehmner wir haben werden).

Anschließend greift sich jede(r) einen Stift und alles, was sie/er benötigt, um die anderen von der eigenen Echtheit zu überzeugen, und wir verwenden so eine Art doppelköpfige Schlange, damit jede(r) Teilnehmer(in) allen anderen begegnet.

Wie Ihr den/die Andere(n) überzeugt, bleibt Euch überlassen - und vor allem dem/derjenigen, die/der überzeugt werden soll. Es wird Leute geben, die Ausweise sehen wollen, also bringt besser einen mit. Andere mögen mit Euch ein "Geheimwort" absprechen, das Ihr später in eine Email steckt und PGP-signiert versendet. Es gibt keine Regeln.

Wenn alle einander begegnet sind, ist die "Party" schon vorbei, und wir kehren zum hoffentlich gut besuchten OpenMonday zurück.

Das Signieren

Wirklich signiert werden die Schlüssel während der "Party" eher nicht. Zwar hat das Unperfekthaus Internetzugang, aber die wenigsten dürften ihre privaten Schlüssel, die man zum Signieren benötigt, dabeihaben.

Statt dessen signiert Ihr später die Schlüssel, von denen Ihr überzeugt wurdet, exportiert sie und sendet sie an die jeweiligen Inhaber(inner).