There are still some things left to do for app, but at this point most of the major functionality I originally envisioned is in place.  The projects mentioned in the "Hacker's Guide" still stand; I should mention however that I'm not planning to address any of them myself any time soon.

Another idea I'm tossing around is the notion of irrefutable types.  Irrefutable types would be like user-defined base types but would be specially handled by the $match translation algorithms in a way that avoids assumptions based on refutability and also the handle/body idiom, allowing for more arbitrary base type structures that can still participate in inductive (non-trivial) pattern matching.  As a special case of matching with such types a new kind of matching statement (a let statement) could be introduced that would allow for a more functional style of programming in certain cases.  Here's an example of what I'm considering at the moment.

  // $flat and $form indicate irrefutable base types
  $flat int; // replaces the current "$base int;" alpha type decl in beta.h
  ...
  $form Foo<class A>(int a, A b);
  $form Bar<class A>(Foo<A> a, int b);
  ...
  $let  Bar<int> b(Foo<int> f(x,y), z) = baz() =>
        int w = bam() =>
  {
    fum(b, f, x+y, w*z);
  }

  ====>

  template <class A>
  class Foo {
    int a_;
    A b_;
  public:
    Foo(int a, A b) : a_(a), b_(b) {}
    // accessors etc...
  };

  // similarly for Bar

  ...

  {
    Bar<int>& b = baz(); // could also be const reference (given appropriate app decl syntax)
    Foo<int>& f = b.a(); // ditto
    int z = b.b();       // notice the lack of "&" for $flat types (about the only difference)
    {
      int x = f.a();
      int y = f.b();
      {
        int w = bam();
        {
          fum(b, f, x+y, w*z);
        }
      }
    }
  }

As always, comments, suggestions, etc. are welcome.