kevmoo @ Work

Migrating to Jaspr

2026-05-11T01:42:32.000Z

Hey folks! It’s high time I modernize this blog. Almost 8 years ago, I moved this blog to Firebase Hosting using a Jekyll static pipeline.

Today, I took the ultimate leap: I migrated the entire blog to Dart and Jaspr!

Here is the complete migration commit: c79f474367.

🛠️ The New Shiny Tech Stack

By moving away from Ruby and Jekyll, I’ve unified the blog entirely under the Dart ecosystem. Here are the core packages driving the new static blog under the hood:

Jaspr & Jaspr Router: Serves as the core component and declarative routing engine, generating lightweight, static HTML page crawls at compile-time.
package:markdown: Reading from the old _posts/ into HTML at build time. I need to figure out if there is a new, better way to do this. At the moment I had to make zero changes to the posts, so that's a win.
package:yaml: Parses the legacy Jekyll Frontmatter headers (titles, dates, tags, permalinks) to populate our static content.dart database.
package:xml: Generate the sitemap and the Atom. Wow. So weird to touch XML again.
Tailwind CSS v4: Provides all utility-first CSS stylings compiled natively via the npm CLI.

I don't like having to work around jaspr_tailwind issue #11. I'll need to investigate if there is a way to wire all of this up without a custom build script calling out to npx.

In the mean time, at least I have a place to put my "think pieces".

"thought pieces"?

🤷‍♂️

Happy hacking!

Hello, Firebase!

2018-04-20T07:00:00.000Z

Hey, folks! Almost 3 years ago, I blogged about moving my blog from Blogger to GitHub. It's high time I moved back to Google, right?

Here's the commit that updated my config.

The only other wiring was setting the FIREBASE_TOKEN in Travic-CI to the value returned by running firebase login:ci. That's about it.

"push to deploy" still works like a champ. The turn-around is super fast. Oh, and it's all on HTTPS.

Cool.

I promise I'll post something before 2020!

Git aliases are awesome, even locally

2015-10-19T07:00:00.000Z

tl;dr: Define personal, project-specific shell commands as a git alias. It's nice.

I moved to Jekyll for my blog in July. To run the blog on my dev machine I need to run

> bundle exec jekyll serve --baseurl ''

Not too crazy, but it's a pain to remember every time I want to run the dev server.

I could put a helper script in the root of the directory for my personal blog, but that's not an option with something like the Dart SDK.

> ./tools/build.py --mode=release --arch=ia32 create_sdk

I could put an a shell alias in my .profile, but it doesn't make sense anywhere except the Dart SDK directory.

Enter git aliases.

I've written about my global git aliases, but I've started using project-local aliases and I'm loving 'em.

For my blog, I tweak .../myblog/.git/config with:

[alias] jekyll-serve = !bundle exec jekyll serve --baseurl ''

For my clone of the Dart SDK:

[alias] create-sdk = "!./tools/build.py --mode=release --arch=ia32 create_sdk"

Try it out.

Scoped to the current directory.
Doesn't add any extra files to the repo that need to be ignored.
Auto-complete nicely with git<tab>.

Dart: #byojsl - Bring Your Own JavaScript Library

2015-10-15T07:00:00.000Z

There's a lot of JavaScript libraries. It'd be nice if you could use them seamlessly from Dart, while maintaining Dart's developer-friendly ergonomics.

At the Dart Summit in April, Dan and I talked about our plans for the future of JavaScript interop: the hashtag-able #byojsl – Bring Your Own JavaScript Library.

With the latest preview release of Dart 1.13 – 1.13.0-dev.7, you can now play with this feature.

Check out the example in the source code.

Nice, huh?

Creating the Dart interop libraries using @Js() annotations allows dart2js to create very efficient Javascript connections to the source library. The interop libraries also give the users of the interop library the developer experience you expect from Dart code: completions, warnings, errors, etc.

If you want to try it out

Download the latest dev release of the Dart SDK - dartlang.org/downloads/archive
The package is published at pub.dartlang.org/packages/js.
Make sure you specify the right constraint in pubspec.yaml – js: ^0.6.0-beta

We'll have proper documentation on the site when 1.13 is ready for release. In the mean time, we'd love feedback as we prepare for the final release.

Updates since initial publish

Hello, GitHub!

2015-07-17T07:00:00.000Z

As I posted and tweeted about yesterday, I wanted to see if anyone had experience going from Blogger to Jekyll on GitHub.

No one chimed in, so I dove it.

I need to do some work on theming, but things seem great so far.

Finally blogging in Markdown. So nice.

If you want to take a look at my (evolving) configuration, the source is here.

Dart Dev: do you have unittest:any in your pubspec?

2015-04-21T21:40:00.001Z

tl;dr If you're using unittest, make sure you have an upper-bound on the package version in your pubspec.yaml.

The new (unit)test package is almost ready and it's awesome.

The 0.12.0 release will be the migration point from unittest to test.

Folks who use unittest will be able to upgrade to 0.12.0 and will get an exported version of test. You'll notice some breaking changes and a lot of deprecations. All future work will happen in the test package, so you'll want to migrate eventually.

In the mean time, if you're not ready to migrate, make sure you don't end up with 0.12.0 accidentally.
You might wonder why your tests start acting weird.

Enforce formatting for your Dart projects

2015-04-08T21:33:00.005Z

A while ago, I wrote about using Travis to add continuous integration to your Dart projects.

I've started adding a new trick to tool/travis.sh: format verification.

I add a script to my tool directory:

#!/bin/sh
dart_files=$(git ls-tree --name-only --full-tree -r HEAD | grep '.dart$')
[ -z "$dart_files" ] && exit 0

unformatted=$(dartfmt -n $dart_files)
[ -z "$unformatted" ] && exit 0

# Some files are not dartfmt'd. Print message and fail.
echo >&2 "dart files must be formatted with dartfmt. Please run:"
for fn in $unformatted; do
 echo >&2 " dartfmt -w $PWD/$fn"
done

exit 1

Then I add a line to the top of travis.sh:

# Ensure the source is formatted
$(dirname -- "$0")/ensure_dartfmt.sh

Here's a commit that adds this support to the dartdoc project.

I find it's much easier to collaborate on a code base when a whole pile of formatting arguments are settled upfront.

Cool? Let me know if you try this on your project.

Angular.ts.js.at.dart.wtf

2015-03-07T08:41:00.000Z

You might have heard that Angular is going to be using TypeScript.

This has lead to questions about the relationship between Angular and Dart.

Let me see if I can help.

First, Angular 1.

Angular 1 JS is crazy popular. Mountains of folks use it. It’s awesome.

Angular 1 Dart was a hand-rolled port of Angular 1 JS. It tried to follow the JS flavor of the framework, while being a true Dart framework. While a lot of folks have used Angular 1 Dart, especially within Google, it turned out to be tough to maintain two separate versions of the same framework for two languages.

Enter Angular 2.

Angular 2 was pitched in October as a better/faster framework built on AtScript – AtScript was an extension of TypeScript from the beginning.

Important point: Angular 2 has always been built on TypeScript.

The Angular/TypeScript announcement is amazing news. The features that were added to AtScript are being pulled into TypeScript.

Important point: AtScript has been merged into TypeScript – one less language to worry about.

TypeScript lets the Angular folks build a framework that targets both Javascript and Dart simultaneously. Check out the Angular Travis page to see build output for both languages.

Important point: Angular 2 has first class support for Javascript AND Dart out of the box.

This leaves us with THE BIG QUESTION:

Why isn’t Angualr 2 just built in Dart?

Answer: the Angular folks want to deliver a great framework for BOTH Javascript and Dart.

Dart generates great Javascript for browsers, but we have work to do to generate reusable Javascript libraries.

The Angular team needs to generate reusable Javascript libraries.

That’s it.

One of my personal goals is to make Dart great for generating JS libraries. We’ll have more to discuss at the Dart summit in April – psst – you should register.

In the mean time, check out the alpha of Angular2 Dart package.

Check out the Angular GitHub project if you want to play with Angular for Dart or Javascript – OR BOTH.

File bugs. File feature requests. Send pull requests.

I’ve had fun using the Dart analyzer to do a bunch of cleanup in the Angular source – it’s nice.

Happy hacking – now with 20% less FUD.

Testing Dart projects with latest release and code coverage

2015-02-17T23:39:00.000Z

Test your package stable and dev

If you’re using Travis CI, it’s as easy as adding a dart: entry to your .travis.yml file. You can specify dev, stable or both to make sure your code works great on current and future build of the Dart SDK.

language: dart
dart: 
 - dev
 - stable

See the dartdoc project for an example.

Here’s a build report for dartdoc on Travis CI.

Getting code coverage with coveralls.io

Setup an account on coveralls.io using your GitHub account.
Pick the GitHub repo for your project
Get the Coveralls “repo token” for the project.
Populate it in Travis CI Settings as COVERALLS_TOKEN – or whatever you like.
Add Coveralls to your travis.sh script.

#!/bin/bash

# Fast fail the script on failures. 
set -e

# Run the tests.
dart --checked test/test_all.dart

# If the COVERALLS_TOKEN token is set on travis
# Install dart_coveralls
# Rerun tests with coverage and send to coveralls
if [ "$COVERALLS_TOKEN" ]; then
 pub global activate dart_coveralls
 pub global run dart_coveralls report \
 --token $COVERALLS_TOKEN \
 --retry 2 \
 --exclude-test-files \
 test/test_all.dart
fi

See the source_gen project for an example.

Here’s the coverage report for source_gen on Coveralls.

Happy hacking!

Equality and Dart

2014-05-27T01:07:00.001Z

A month ago I asked a question on my blog about a piece of Dart code.

For the below class, what are at least two things wrong with the implementation of operator ==.

class Foo {
 int _a;
 int _b;

 int get a => _a;
 int get b => _b;

 ...

 bool operator ==(Foo other) {
 return other._a == this._a && other._b == this._b;
 }
}

A number of guesses were posted to the G+ discussion.

Context: designing types for reuse is tough

If Foo is only used within one library – so it should be named _Foo – the existing implementation might be totally fine.

But if Foo is…

Used a lot within a single library or package
Part of a code base with a lot of developers
Part of a public package
Serves as a base class

…then you have to think a lot harder about its implementation.

Special Equality

The parameter to operator == should always be Object.

Don’t believe me? Paste the code below into try.dartlang.org. I’ll wait.

void main() {
 var items = [0, 1, new Bar(5), 6, 7];
 print(items.contains(6));
}

class Bar {
 final int value;
 Bar(this.value);
 bool operator ==(Bar other) => value == other.value;
}

operator == is used in Iterable for contains, where, and many other methods. Map also uses == for its final check after finding matching hash codes. If there is any chance that an instance of your class will have equality checked with any other type – either directly or via very common Dart classes – you should not make assumptions about the argument to == except that it’s not null. Dart takes care of the null check for you.

This is easy to fix:

class Bar {
 final int value;
 Bar(this.value);
 bool operator ==(Object other) => 
 other is Bar && value == other.value;
}

General Equality

Just like relativistic physics, the special case is pretty straight forward. The general case is a bear.

I read that Special Relativity took Einstein 8 weeks where General Relativity took him 8 years, but I digress.

The special case is a black-and-white comparison: is the operand the same type as this or not. The general case introduces a pile of gray.

Dart has implicit interfaces. This means anyone can implement your Foo or Bar class.

Let’s say we fixed our original example for the special case:

class Foo {
 int _a;
 int _b;

 int get a => _a;
 int get b => _b;

 bool operator ==(Object other) {
 return other is Foo && other._a == this._a && other._b == this._b;
 }
}

What if someone implements Foo in another library.

import 'package:foolib/foolib.dart';

class MyFoo implements Foo {
 int get a => 41;
 int get b => 42;
}

Try doing if (foo == myFoo).

You’ll get a runtime error along the lines of MyFoo does not have instance property _a.

General Equality: simple fix

The simple fix is, well, simple. Avoid using private members of objects you don’t completely control. In the case of == that means any private members on other.

This problem goes beyond operator == and extends to any method anywhere in your library.

Consider the static distance method below.

class MyPoint {
 num _x, num _y;
 num get x => _x;
 num get y => _y;
 static double distance(MyPoint a, MyPoint b) {
 // should you access _x or _y here?
 }
}

See what I mean?

General Equality: simple mistakes

Avoiding private members is only part of the problem. Let’s look at MyPoint again.

class MyPoint {
 final num x, y;
 MyPoint(this.x, this.y);
 bool operator ==(Object other) =>
 other is MyPoint && other.x == x && other.y == y;
}

No private members. No type assumptions. We’re home free! Right?

Try this in try.dartlang.org:

class MyPoint {
 final num x, y;
 MyPoint(this.x, this.y);
 bool operator ==(Object other) =>
 other is MyPoint && other.x == x && other.y == y;
}

class MyPoint3 extends MyPoint {
 final num z;
 MyPoint3(num x, num y, this.z) : super(x, y);
 bool operator ==(Object other) =>
 other is MyPoint3 && other.x == x && other.y == y && other.z == z;
}

void main() {
 var mp = new MyPoint(1,2);
 var mp3 = new MyPoint3(1,2,3);

 print(mp == mp3); // true
 print(mp3 == mp); // false
}

You’ve just broken one of the three laws of equality.

Cue mass hysteria.

There are solutions to this problem, but they are not simple. We’ll have to bother Florian Loitsch for details.

…and I haven’t even gotten into implementing hashCode and handling mutable fields – here’s a taste.

Now what?

Keep calm, but be paranoid.

Be careful when implementing ==.
- Make sure it’s something you want to sign up for.
- Read up on implementing hashCode correctly.
- If you’re class has mutable state, be afraid!
Always type the argument to operator == as Object and do a type check.
If your class is public, remember: any instance of Foo may not be my implementation of Foo.
- Stick to the public interface.
- Document what you consider equality.

An alternative: public class, private implementation

If you’ve dug around the Dart source code, you’ve likely seen this pattern:

abstract class SomeClass {
 int get a;
 String get b;
 bool someMethod();

 factory SomeClass(int a, String b) => new _SomeClassImpl(a, b);
}

Besides allowing us to efficiently support both the Dart virtual machine and compiling to Javascript, this pattern also allows one to detect random implementations of a type.

class _SomeClassImpl implements SomeClass {
 final int a;
 final String b;
 bool someMethod() ...

 _SomeClassImpl(this.a, this.b);

 // No impersonators allowed
 bool operator ==(Object other) =>
 other is _SomeClassImpl && other.a == a && other.b == b;
}

This pattern also allows you to lock down an object system where an arbitrary instance won’t fly.

Future and Zone are examples from the Dart SDK. You won’t get very far trying to implement or extend either of them – at least if you try to use them in place of their native implementations.

This post was edited and published using StackEdit. Freakin’ awesome. I may not ditch blogger after all.

Delivered: Pop, Pop, Win! ported to StageXL

2014-05-02T21:09:00.001Z

The Dart Editor ships with a Minesweeper-inspired game – Pop, Pop, Win! – that I originally hacked together in late 2012.

About a month ago, I made an open request for a Dart community member to port the Pop, Pop, Win! demo to StageXL – a powerful and flexible 2D graphics library for Dart written by Bernhard Pichler.

Alex Gann stepped up and delivered.

Once Dart v1.4 is released, you'll be able to explorer the source code and run the game from the welcome page of the Dart Editor.

In the mean time, you can browse the source on the GitHub source mirror.

I'm also keeping a running copy of the latest code on this GitHub page.

Alex did a bunch of work to optimize image and audio formats, including turning the audio files into a sprite. The download size of the entire game dropped by over a third: from 1.8MB to 1.1MB.

You'll also notice you can play games of arbitrary complexity – click on the logo for help and to switch difficulty.

Huge thanks to Alex for his hard work.

Huge thanks to Bernhard for the great StageXL package and for helping out Alex with a few feature requests during development.

Method Piping - Dart Syntax Proposal

2014-04-28T15:28:00.002Z

Update 1: I was delighted, but not totally surprised that someone else thought this was a good idea – 2 months ago. Patrice Chalin wrote up the proposal on his blog in February and filed a feature request. I've closed my request as a duplicate of his.

Disclaimer: This is not in anyway official. It's an idea. If you're excited about it, great. Please star the associated issue. I'm trying to judge interest in the Dart community.

One of the first Dart issues – the 13th, to be precise – was for C#-style extension methods.

This is not possible in a consistent and performant way due to Dart's type system.

But I'm pretty sure that most Dart developers that want C#-style extension methods would be happy with something much more simple.

Imagine the following code

...
class Foo {
 ...
  void fooMethod() {
   ...
  var items = [true, null, "Test", 42];
  var isEven = _isEven(countWhere(items, (e) => e is bool)); 
  }
}

_isEven could be an instance method on Foo, or a static method on Foo, or a top-level method in the current library.

countWhere could also be a instance or static method on Foo, or a top-level method on the current library or an imported library. It could also be a function defined in-line in fooMethod.

Now imagine an alternative syntax for the same behavior, with a new sugar in the form of |> – the method pipe.

...
class Foo {
 ...
  void fooMethod() {
   ...
  var items = [true, null, "Test", 42];
  var isEven = items |> countWhere((e) => e is bool) |> _isEven(); 
  }
}

Method pipe is simple. Anything of the form

g(f(expression))

Can be written as

expression |> f() |> g()

Basically, the expression on the left side of |> is passed as the first parameter of the function on the right of |>.

What about multiple arguments? Named arguments?

If you had function

int count(int a, int b, int c, {int d}) { ... }

You can call it as

count(1, 2, 3, d: 4);

1 |> count(2, 3, d: 4);

What if you try to call a method that has no default parameters? Or you try to call a field like a method?

The same thing that happens now.

int value = 5;
void run({String arg}) { ... }

// Today: Warning in the analyzer and errors at runtime
value(10);
run("test");

// Tomorrow: Warnings in the analyzer and errors at runtime;
10 |> value();
"test" |> run();

See where I'm going?

The method pipe syntax – |> – is completely up for debate. But I like the model. One could create and import a library full of top-level methods that consume Iterable – groupBy, countWhere, wrapWithUnmodifiableList, etc and write.

var items = [1, 2, 3, 4, 5];

var groups = items |> groupBy((e) => ...);
var evenCount = items |> countWhere((e) => ...);
var readOnly = items |> wrapWithUnmodifiableList();

Thoughts?

Here's the feature request.

There are (at least) two things wrong with this Dart code

2014-04-26T22:45:00.000Z

Specifically with operator ==.

class Foo {
 int _a;
 int _b;

 int get a => _a;
 int get b => _b;

 ...

 bool operator ==(Foo other) {
 return other._a == this._a && other._b == this._b;
 }
}

Any guesses?

Wanted: Hacker to port Pop, Pop, Win! to StageXL

2014-03-30T05:29:00.001Z

tl;dr: Want an interesting Dart project? Port Pop, Pop, Win! to StageXL. If you do a good job, you're code will get into the Dart SDK.

When I wrote Pop, Pop, Win! I hacked together an HTML Canvas graphics library into bot_web. The library – bot_retained – did everything I needed, but I really haven't done much with it in over a year.

In the mean time, StageXL has been going nuts. It supports rendering to Canvas and WebGL. It supports Texture Packer. Bernhard has been keeping it fresh.

I'm actively trying to cleanup a bunch of little projects I've built over the last couple of years. Deprecating my own retained graphics library and moving folks towards StageXL seems like goodness.

Interested in doing the port?

The source code for PPW now lives in the Dart SDK. I'd suggest doing a copy-paste of the project into a new Git repository and starting there. The graphics bits are pretty well isolated. If you're pretty serious and can show that you've made a stab, I'm happy to offer help.

Dig in. Send me a link to your project on GitHub if you make progress or hit any bumps.

Happy hacking!

Tracking changes to PART of the Dart SDK

2014-03-28T16:23:00.000Z

For historical reasons, the Dart project uses Subversion for source control.

There are a few folks who would like to use Git for the project, including me, but it's not the top of our priority list.

You can get some of the benefits of Git by looking at or even cloning our GitHub mirror.

One of my favorite uses: tracking changes to an individual package.

Steps

1 - Navigate to a package of interest, say unittest.

2 - Click on the History link.

3 - Notice that kevmoo has been making a lot of changes lately.

This is a great way to see what changes have happened since the latest release of a package or just to track individual parts of the Dart project.

Nice, huh?

Dart Package Devs: Put version constraints in your pubspec

2014-03-25T19:15:00.002Z

tl;dr

Update: this guidance is specific Dart packages. I'll write about Dart apps soon.
Read about the Pub Versioning Philosophy.
If your package uses new features in the SDK or packages, make sure you set an inclusive minimum version constraint – >= X.Y.Z – to avoid breaking folks who have not yet upgraded.
Set exclusive maximum version constraints – <X.Y.Z – to make sure major releases of the SDK and packages don't break your code.
Understand how pre-v1.0 are versioned with regard to breaking changes.
Take a look at pubspec files in our SDK to understand how we handle versioning. Example: http package pubspec.yaml.

New features and minimum version constraints

Dart v1.3 is coming soon. String has learned a few tricks since v1.2, specifically:

String padLeft(int newLength, String padding)
String padLeft(int newLength, String padding)
String trimLeft()
String trimRight()

Awesome, right? I can imagine package authors doing the following:

Download Dart 1.3 Editor and SDK
Replace all internal hacks with new String functions.
Release?

No! #3 should be: Update your pubspec.yaml.

pubspec.yaml content

In the Dart Editor

Setting the minimum SDK to 1.3.0 tells the pub tools and your users the users that a package requires at least v1.3 of the Dart SDK. Better to get an error from pub install or pub update than to get static warnings or runtime errors about missing functions.

You'll also notice more than just an inclusive minimum SDK constraint – >=1.3.0 – there's also an exclusive maximum SDK constraint – <2.0.0.

Our promise it to follow semantic versioning for the SDK and our shipped packages. The short version:

For a version X.Y.Z
Increases to Y indicate new features, but no breaking changes.
Increases to X indicate breaking changes.

It should be safe to set your maximum SDK version to be any release up to, but not including, v2.0.

Packages and pre-v1.0

The same applies to packages managed by the Dart team, like unittest, args, path, etc.

We have a number of packages that are pre-v1.0 – unittest is a great example.

unittest is one of our oldest and most used packages. We'd really like to lock it down and clean it up before releasing something we consider v1.0.

If you look at the changelog for unittest, you'll see a number of breaking changes between v0.9.2 and v0.10.0.

For pre-v1.0 packages, we bump the versioning logic up a level, so for version 0.Y.Z, changes to Y are breaking and changes to Z are non-breaking.

Look again at the changelog for unittest. You'll see a number of features marked as DEPRECATED. These are things that will likely go away – stop working – in v0.11.0 of unittest.

If you want to make sure you code does not suddenly break, you should set a version constraint on unittest of something like >=0.10.0 <0.11.0.

Am I missing new hotness?

A lot of folks dislike setting maximum version constraints.

I always want to be running the new hotness!

I don't want to miss out on new features!

pub upgrade is your friend.

If you run pub upgrade from the console or within the Dart Editor, you'll see useful hints when there are newer versions of packages than what you currently specify.

You can then carefully update and check version constraints before you release.

If you want to visualize a complex package with many dependencies, check out pubviz.

Happy hacking!

pkg/unittest: shedding some cruft, getting some awesome

2014-02-07T17:17:00.001Z

9:15am 7 Feb, 2014 These changes have not been released to the pub site yet.

tl;dr

If you're testing code using Future, Stream, or anything async, you'll notice a lot fewer crashes and a lot more helpful stack traces.
If you're subclassing Configuration, keep reading.
If you're using APIs on TestCase, keep reading.
If you're just using test, group, expect, etc. you're likely fine.
Update pub dependencies on unittest to includes 0.10.0 to get the new hotness. (You might have something like >=0.9.0 < 0.10.0, change it to >=0.9.0 <0.11.0)

The upcoming 0.10.0 release of unittest will have a lot of changes. Here's a copy-paste of the current changelog.

Each test is run in a separate Zone. This ensures that any exceptions that occur is async operations are reported back to the source test case.
DEPRECATED guardAsync, protectAsync0, protectAsync1, and protectAsync2
- Running each test in a Zone addresses the need for these methods.
TestCase:
- Removed properties: setUp, tearDown, testFunction
- enabled is now get-only
- Removed methods: pass, fail, error
interactive_html_config.dart has been removed.
runTests, tearDown, setUp, test, group, solo_test, and solo_group now throw a StateError if called while tests are running.
rerunTests has been removed.

These changes cover three big areas:

Remove unsupported APIs. The interactive test case runner hadn't been touched in a long time and it didn't support a number core test case features, like setUp and TearDown. The rerunTests function only existed to support the interactive runner and introduce a lot of weird state in unittest.
Make TestCase immutable. Expect more changes here. TestCase should contain the logic to run the test. The result of the run should be in another object. We're getting there.
Make testing async code easier. All tests are now run in a Zone. This means all any errors thrown by async operations are now funneled to the calling test case without requiring guardAsync or a protectAsyncN function (these are now deprecated).

Going forward, we're looking into more changes:

Remove more state from TestCase. enabled, isComplete, passed, and startTime may be removed from this class and exposed somewhere else.
I'm hoping to have a model where TestCase exposes Future<TestResult> run([Configuration config]) or similar.
More powerful ways to run unit tests, making it easy to run tests is parallel in zones, for example.

I'd like unittest to evolve to expose a very simple API that others can build on, with a layer of "easy" for those that just want to get something tested without a lot of ceremony.

Your thoughts and suggestions are welcome!

Happy hacking.

Google Compute + Docker + Dart

2013-12-31T18:52:00.000Z

Follow the instructions here: http://docs.docker.io/en/master/installation/google/

Assuming the last instruction works:

sudo docker run busybox echo 'docker on GCE \o/'

Run this:

sudo docker run sethladd/docker-dart dart --version

You should see something like:

Pulling repository sethladd/docker-dart
3df1fbb95c1f: Download complete
8dbd9e392a96: Download complete
5581b213d8ed: Download complete
5242b0ef847e: Download complete
33626c0daf8f: Download complete
8b9f8f28678f: Download complete
3696f4eade8a: Download complete
a805a53d4a72: Download complete
Dart VM version: 1.0.0.10_r30798 (Mon Dec 2 10:31:15 2013) on "linux_x64"

You're now running Dart via Docker on Google Compute Cloud.

Cool!

Props to +Brian Dorsey and +Seth Ladd for putting the pieces together.

Joining Google

2013-12-07T15:11:00.002Z

I have much less to say than the last two times I posted about changing jobs.

After 5 years freelancing, I'm going (back) corporate.

After running around the Southern US and South America, my wife and I are ready to settle back in Seattle.

After coding in C#, XAML, Ruby, and Javascript, I've finally found a development platform that I'm totally in love with: Dart. I want to make it better full time.

I'll be working in the Google office in Seattle with some great folks working on some amazing technology.

December 16 is my start date.

I can't wait.

brew install dart-editor

2013-11-07T23:57:00.002Z

If you do any open source development on Mac, you're probably using Homebrew. (If you haven't heard of Homebrew, read up here.)

I've created a Homebrew formula that will install the Dart SDK, Dart Editor, and optionally content_shell for headless browser testing.

Step 1: "tap" my Homebrew repository to add the dart-editor formula to your Homebrew installation.

~/> brew tap kevmoo/kevmoo

Cloning into '/usr/local/Library/Taps/kevmoo-kevmoo'...
remote: Counting objects: 227, done.
remote: Compressing objects: 100% (154/154), done.
remote: Total 227 (delta 73), reused 225 (delta 71)
Receiving objects: 100% (227/227), 27.55 KiB | 0 bytes/s, done.
Resolving deltas: 100% (73/73), done.
Checking connectivity... done
Tapped 2 formula

Step 2: Install dart-editor. (Add the optional --with-content-shell flag if you like.)

~/> brew install dart-editor --with-content-shell

==> Downloading https://gsdview.appspot.com/dart-archive/channels/dev/release/30821/editor/darteditor-macos-x64.zip
Already downloaded: /Library/Caches/Homebrew/dart-editor-30821.zip
==> Downloading https://gsdview.appspot.com/dart-archive/channels/dev/release/30821/dartium/content_shell-macos-ia32-release.zip
Already downloaded: /Library/Caches/Homebrew/dart-editor--content_shell-30821.zip
==> Caveats
DartEditor.app was installed in:
 /usr/local/Cellar/dart-editor/30821

To symlink into ~/Applications, you can do:
 brew linkapps

Note the mention of brew linkapps. This will put a symbolic link to Dart Editor.app in /Applications so it's easy to find.

What do I get?

You'll have the following binaries added to your Terminal path:

dart
dart2js
dartanalyzer
dartdoc
pub
content_shell (if you added the option)

Now you're ready to hack on Dart from the Editor and the command prompt.

Why do it this way?

You get Homebrew conventions for free, which includes putting part of the Dart SDK in the right spot for use from Terminal.
It's easy to uninstall everything.
It's easy to upgrade. brew update updates the dart-editor formula, too.
It's easy to install development versions. Once they are available, you can use brew install dart-editor --devel

Let me know if you have questions.

Pull requests are welcome!

Happy hacking!

Dart to Javascript output size: what a difference a year makes.

2013-10-31T23:44:00.000Z

About a year ago I posted on the improving output size of Dart to Javascript (dart2js) compiler.

For Pop, Pop, Win!, I was taking the ~441KB output from dart2js, pumping it through the Google Closure Compiler to get a Javascript file around 389K.

With gzip over the wire, the download size was 90KB.

My words at the time:

I certainly don't feel I need to justify the javascript output size for non-trivial apps anymore.

That was with build 15005 of the Dart SDK.

What a difference a year makes.

Today, with the latest trunk release – v0.8.9, build 29656 – we are doing even better.

The dart2js compiler, without the help of other tools, is generating an output file around 263KB. That's 40% smaller that a year ago.

The gzip size – which is what really matters, since it's the cost-on-the-wire – is at 70.5KB. Over 20% smaller.

This includes content like the texture mapping data which is 39KB on disk.

For an app with high quality images, audio, and fonts the total cost of the compiled code come in right at 4% of the total download for the app.

Impressive!

My Global Git Aliases

2013-09-25T15:03:00.002Z

You know you can create your own git commands right? Git supports custom aliases. They rock.

The hello world examples are just creating shortcuts for existing commands.

git config --global alias.co checkout

Simple, right?

You can put global aliases in your user Git config file: ~/.gitconfig

You can also put them in the config file for a given repository: project/.git/config

Here's a list of mine.

Safe pull. Always does a fetch, but only updates your local branch if you can fast forward. As easy way to make sure you don't create a merge with upstream due to local weirdness.

Definition: sp = pull --ff-only

Usage: git sp

Fetch all. Fetch all remotes for this repository. Used a lot when I have an upstream branch and my fork.

Definition: fa = fetch --all

Usage: git fa

Grep with a simple string match. See the full breakout here. Basically lets my search for simple strings across text files explicitly without regex. Move into a subdirectory and grep will search only that dir and below. Use it constantly.

Definition: gp = grep -I -F -n -e

Usage: git gp 'void main('

Grep TODOs. Find all instances of TODO. Move into a subdirectory and grep will search only that dir and below.

Definition: g2do = grep -n TODO

Usage: git g2do

Github! Open the GitHub page for the current repo. Found here. There are a lot of ways to skin this cat. This works for me on mac.

Definition: gh = "!open https://github.$(git config remote.origin.url | cut -f2 -d. | tr ':' /)"

Usage: git gh

Find file. Exactly what it says. Finds file where any part of the file path matches the provided string.

Definition: ff = "!git ls-tree -r --name-only HEAD | grep -F"

Usage: git ff index.html -- Note, this will include /index.html.haml and /index.html/resources/foo.png.

Hope you find some of these useful.

Happy hacking!

Dart: dynamic vs Object in arguments? Pretty straigtforward

2013-09-11T15:03:00.000Z

It's one of those rules that makes total sense the first time you here it.

It's actually outlined concisely in the style guide: DO annotate with Object instead of dynamic to indicate any object is accepted.

// **Use Object**
// Accepts any object.
void log(Object object) {
  print(object.toString());
}

// **Use dynamic**
// Only accepts bool or String, which can't be expressed in a type annotation.
// Probably should document what we expect arg to be.
bool convertToBool(dynamic arg) {
  if (arg is bool) return arg;
  if (arg is String) return arg == 'true';
  throw new ArgumentError('Cannot convert $arg to a bool.');
}

The way I like to think about it: dynamic is our crutch until Dart has union types.

Depending on whom you ask, explicitly specifying dynamic in convertToBool is unnecessary. But I like being explicit.

Happy hacking!

Intent to Implement: CollectionView and SelectionManager in Dart for ObservableList

2013-09-09T20:27:00.004Z

I'm getting into some non-trivial infrastructure and I wanted to put the word out.

The story:

The Observe package exposes ObservableList<E>, which works with Model Driven Views (mdv) to enable dynamic lists in your UI. This is all wrapped up with Polymer.
I'd be nice to have a generic way to sort and filter an input list. CollectionView<E> wraps an ObservableList<E> with filter and sort properties. Changes to the source list or the properties cause the CollectionView, which is a readonly implementation of ObservableList to update accordingly.
SelectionManager<E> also wraps an ObservableList<E>. It appears as ObservableList<Selectable<E>>. Selectable has two properties: E get value and bool get isSelected. It handles the semi-gnarly process of managing selection (single-selection to start with, then multi-selection at some point--hopefully).

These are core infrastructure pieces that, frankly, I miss from .NET/WPF.

I'm not ready to share code yet, but I wanted to give folks a heads-up.

Ideally, these types of concepts would be once (or rarely), tested like crazy, and used everywhere.

I may try to get them into the Observe package at some point, once they are baked.

If anyone has suggestions, feedback, other implementations, or interest, please let me know.

Dart PSA: noSuchMethod - When in Doubt, Don't

2013-07-12T14:30:00.002Z

Public service announcement for Dart developers, especially those publishing packages on Pub.

Don't go crazy with noSuchMethod.

noSuchMethod is kind of like QR codes.

While funny, I think this goes a bit too far.

I do think there are cases where QR codes are useful, but they are limited. Kinda' like noSuchMethod.

Don't use noSuchMethod to be lazy

I know! I'll use noSuchMethod to emulate getters and setters on my class instead of writing them out by hand. I'll just store all of the values in a Map. My code will seem pretty and I won't have to worry about adding new properties as I think them up. Oh, and I won't have to worry about updating the constructor either!

Don't use noSuchMethod to be clever

I know! I'll use noSuchMethod to automagically support method_name usage for methodName using reflection since some people like to access members with underscores!

Don't use noSuchMethod to make Dart look like Ruby

I know! I can use noSuchMethod to make setting up this...uh...thing look like a DSL...uh...thing because a blog once said that DHH or RMS or BBQ or someone smart said that's cool.

Don't.

Creating a mock for testing? Probably.
Creating a proxy for something dynamic? Maybe.

Next time you think about using noSuchMethod, right click on something real in the Dart Editor.

See all of that awesome!

Before the VI guys get all huffy puffy about IDE wimps, let me stress this is not just about the IDE.

This is about getting helpful warnings and errors in checked mode.
This is about generating valid, small, efficient Javascript.
This is about generating helpful documentation, even if you don't annotate anything.
This is about the sanity of future users of your libraries and maintainers of your code.

So please.

Don't use noSuchMethod unless you have to.

When in doubt, DON'T!

Please.

kthxbye.

Reader's Swan Song: Blog First; Tweet, Plus later

2013-07-01T19:15:00.001Z

tl;dr: Do your opining, ranting, lecturing, and quipping on your blog. Drop a link on Google+, Twitter, whatever. Don't grow your content in a walled garden.

I spend my days swimming in a pool of Google's Kool-Aid: Chrome, Dart, Closure Compiler, Plus, Analytics, oh yeah, and Search.

Util today, Google Reader (R.I.P.) was towards the top of that list. I'm now one of many jumping between a handful of want-to-be alternatives with no clear winner. While I'm still not settled on how I'm going to consume blogs, I have come to a conclusion on the production side.

I'm going to blog more -- a lot more.

I have a mountain of love for Google, but in end it's a company with share holders. While my site is set up via Google Apps and Blogger serves my RSS/ATOM feed, I own the domain and the content. I can move it all to Heroku or Azure tomorrow if I wanted.

That's a good thing.

You don't need to create a Google+ account or ignore sponsored tweets for Hydraulic Fracturing to see my rants.

That's also good thing.

So let's take the death of Reader as a call to action.

Let's restart discussions...

About ATOM and RSS.
About metadata and aggregation.
About annotation and reputation.
About hypothes.is and app.net and other folks trying to evolve a stagnant space.

See you on the open, aggregated, hyperlinked, distributed, web.

Dart is a great language for shell programming, too

2013-02-06T17:32:00.001Z

I asked Twitter nicely yesterday. The only response:

I don't dislike writing bash scripts. I hate it. I also hate the lack of portability, as pointed out by +Daniel Steigerwald:

Great idea, +Daniel Steigerwald, but why use NodeJS when I could use Dart?

If you fetch the latest version of the Dart Bag-of-Tricks, you'll notice a new binary bin/bench.

If you're running bash and dart is in your path you can execute this directly. Otherwise run it through dart: dart bin/bench.

If you add bot.dart/bin to your path you can do things like this:

There is also a paramater -r, --run_count (defaults to "20")

Dart is more than just a good tool for web apps.

Happy hacking.

Headless Browser Testing: Dart, DumpRenderTree, drone.io

2013-02-01T03:29:00.002Z

When writing any software, even for the web, I try to do as much testing as possible outside the browser.

A lot of great testing can be done of algorithms, data models, and business logic without booting up Chrome.

Node.js enabled this with Javascript. Dart has had an out-of-browser--read console--story since day one.

But some things you must test in a browser.

The Dart Bag of Tricks (BOT) has had browser tests since the beginning. There are only a few tests that must be run in the browser, but I make sure to run all tests both on the console and in the browser if they can run both places.

Browser tests are great, but they don't fit well into a build workflow or a continuous integration tool.

For that you need a way to run and control a browser (or a browser-like thing) via the console and get results out. Enter DumpRenderTree.

DumpRenderTree - Chrome without the chrome

DumpRenderTree (DRT) is a great little tool hidden in the guts of WebKit.

By default, DRT prints out an obscure text format representing the hierarchy of elements on the provided page.

Here's the output for DumpRenderTree example/fract/fract_demo.html

Content-Type: text/plain
layer at (0,0) size 808x820
  RenderView at (0,0) size 800x600
layer at (0,0) size 800x820
  RenderBlock {HTML} at (0,0) size 800x820
    RenderBody {BODY} at (8,8) size 784x804
      RenderHTMLCanvas {CANVAS} at (0,0) size 800x800 [bgcolor=#808080]
      RenderText {#text} at (0,0) size 0x0
#EOF
#EOF

DRT is controlled mostly through Javascript in the test page by via window.testRunner.

Here's the script block that lives in test/harness_browser.html:

<script>
 // only run if testRunner is defined -- we're in DRT
 if (window.testRunner) {

 // Don't dump the structure. Just the text of the output plus console output
 testRunner.dumpAsText();

 // Don't finish when layout is done. Instead, wait to be notified
 testRunner.waitUntilDone();

 // listen for messages from the test harness
 window.addEventListener("message", receiveMessage, false);

 // listen for unhandled exceptions
 window.addEventListener('error', onError);
 }

 // if there is an unhandled exception, tell DRT we're done
 function onError(event) {
 testRunner.notifyDone();
 }

 // if the test harness sends a done message, tell DRT we're done
 function receiveMessage(event) {
 if(event.data == 'unittest-suite-done') {
 testRunner.notifyDone();
 }
 }
</script>

And since everything is keyed off the existence of window.testRunner, none of this affects the behavior of tests running normally in a browser.

Here's the first few lines of output from DumpRenderTree test/harness_browser.html:

Content-Type: text/plain
PASS
All 109 tests passed
Collapse All
bot
 
(4/4)
bot - Enumerable
 
(19/19)
bot - Enumerable - group

Compare to the content running the tests in the browser:

Getting DumpRenderTree

DRT is part of Linux and Windows builds of the Dart Editor now (look in the chromium) directory. It will be part of builds for Mac soon.

If you want to get DRT that is compatible with the latest integration build of Dart - 0.3.2.0 (r17657) - grab this guy.

Just make sure the DumpRenderTree executable is on your path when running tests.

Bringing it all together

drone.io supports DumpRenderTree for Dart projects. Read about it here.

The trick is creating a script that returns an exit code of zero for success and not zero (1 is pretty standard) for failure.

Check out the script I created for BOT.

And let me know how it goes for you.

Happy hacking.

Dart Widgets Dev Journal 1 - Basic Animations

2013-01-11T17:50:00.002Z

tl;dr: Implementing features similar to Bootstrap is hard without basic animation support in Dart. Basic animation support is not as easy as you'd think. I've made a stab. Check out the demo.

I've started a new Dart project - Dart Widgets. The inspiration is Bootstrap, but with a focus on features that map cleanly to Web Components.

While digging into Bootstrap, I realized that there was a heavy dependency on jQuery--specifically the show/hide/toggle functionality. This is critical for expanders, menus, modals, pretty much everything.

Show, hide, toggle

It turns out implementing show/hide/toggle is not as easy as one might guess.

One could naively toggle display: none; in an element's style attribute and call it a day, but a lot of edge cases would be missed.

Throw in the ability to optionally animate the show/hide behavior and things get a lot more complicated.

A short list of the cases to ponder:

Element with a non-standard display value. (e.g. a div inherited a display of inline-block)
Element with a local display of none
Element inherited a display of none
Show is called while an element is hiding and vice versa
Toggle is called 10 times before the first animation finishes
Show is called on an element with effect A while effect B is hiding it.

Huge props to the jQuery and jQuery-ui folks for tackling this problem. Their code served a great starting spot. I feel bad that they had to implement this logic in Javascript.

Test

I can't tell you how valuable test-driven development was in getting this project off the ground. It would have been next to impossible to ensure all of the edge cases were handled cleanly.

I need to write another post about how my approach to testing in Dart has evolved. Let's just say I didn't code up 939 tests by hand.

After a lot of head scratching, I think I ended up with pretty clean, extensible model.

As proof, I offer the code for doing a open/close door effect:

class DoorEffect extends Css3TransitionEffect {
 DoorEffect() : super(
 '-webkit-transform',
 'perspective(1000px) rotateY(90deg)',
 'perspective(1000px) rotateY(0deg)',
 {'-webkit-transform-origin': '0% 50%'}
 );
}

There are still a few things I'd like to get working--get tests working in Firefox, find a way to handle browser prefixes cleanly--but generally I'm happy with progress.

Check out the demo.

Check out the code.

Let me know what you think.

Excited to see dart2js minified output getting smaller (real world numbers below)

2012-11-16T14:58:00.003Z

I noticed r15005 turns on more renaming in dart2js with --minify so I thought I'd see the impact on Pop, Pop, Win!

The last time I did a build and deploy of PPW was on r14873.

Here are the sizes of game.dart.js

dart2js	617,201 bytes
closure compiler	621.07KB
gzip (via http)	107.7KB

Notes:

dart2js is running with the --minify flag
I'm using the closure-compiler with default settings. Build from 17 Sept, 2012
Notice how the output is bigger from closure? This is because output is optimized for gzip. Not intuitive, until you see the network panel in Chrome Dev Tools.
gzip is the size Chrome sees over the wire. Most servers gzip payloads. It's critical to pay attention to this number and not just the size on disk.

Now with the bleeding edge build r15005

dart2js	451,183 bytes	~33% smaller
closure compiler	388.71 KB	~37% smaller
gzip (via http)	90.2KB	~16% smaller

Notes:

The output from dart2js is substantially smaller. This is just the work from the dart2js guys recently. Amazing.
This time the output from the closure is smaller than the input (~12%). I can only speculate why. Perhaps the new minified output is more optimizable?
The gain with gzip is not as big (~16%). I'm not surprised by this. PPW is a pretty big game. The json that stores the texture data alone is huge.

Keep in mind, the Dart source for the game is 1.5 MB as reported by dart2js.

info: compiled 1576654 bytes Dart -> 451183 bytes JavaScript in web/game.dart.js

Is it fair to say we're getting ~94% smaller output? It depends on how valid one considers the the Dart code size reported by dart2js.

But I certainly don't feel I need to justify the javascript output size for non-trivial apps anymore.

Great work folks!

Dartsweeper: Dev Journal 3--Graphics, Animation, Audio

2012-09-19T17:17:00.002Z

I've been busy the last few weeks. I've had to give more time to another gig, so I've slowed my progress on the ~~Dartsweeper~~ Pop, Pop, Win! But I've made some great tractions. Check out the demo at sweeper.j832.com.

Graphics and animation with TexturePacker

Graphics for the Pop, Pop Win! (PPW) are packaged using TexturePacker. TexturePacker takes a number of source images and produces an optimized texture atlas.

PPW has two texture files: one for square textures (that don't have transparency) and one for the textures that need transparency. Using a jpeg for the textures that don't require transparency saves a lot of bandwidth.

TexturePacker outputs a map file that provides the location of each source image in the output map. Initially I was given an XML file which I parsed with the dart-xml library. (Thanks, John!) I converted the XML to JSON which I stored as a string in code and deserialized with dart:json.

Then I realized I was being dumb.

First, I learned TexturePacker can output json directly. So long xml parsing.

Second, I realized that valid json can be provided as a literal for Map in Dart. Goodbye JSON decoding.

Using some simple canvas tricks, I can now easily display graphics and animations representing over one hundred source textures using only two input files.

Audio

Supporting audio is super easy with AudioContext. I started with the BufferLoader sample from an HTML5 Rocks tutorial and converted it to Dart.

I went a bit further and generalized all of my resource loading into an abstract ResourceLoader class which is then subclassed by ImageLoader and AudioLoader. I plan to migrate these classes into dartlib in the near future.

Easy.

Issues

In my last post, I mentioned an issue using offsetX and offsetY in MouseEvent in Firefox. The bug has been fixed so I removed my work around.

The other glaring issue is the lack of audio support on browsers other than Chrome. Chrome is the only browser that supports AudioContext (that I tried). I've dealt with cross-browser game audio before--see Agent8ball--and I'm not super excited to fix it here. In the mean, just use Chrome.

Next Steps

A few more graphics tweaks.
A few more sound effects.
Mobile support.
Some loading UI.

You can help

Don't forget all the source is on GitHub. Open issues. Fork it.

Let me know if you have any questions.

Happy hacking...and popping.

Dartsweeper: Dev Journal 2--now with Canvas

2012-08-23T18:14:00.000Z

Looks can be deceiving

Looks about the same as last time, right? The visuals and interaction were designed to be almost identical, but the plumbing is very different.

The original, HTML DOM version used a table to render the game board. It's straight forward to let DOM elements handle layout and mouse interaction. Throw in a little CSS and you have a functional—albeit ugly—game.

But if one wants to make something really amazing, without fighting a Matryoshka doll of layout and CSS issues, one should leave the DOM behind.

Since I've decided leaving the third dimension for later, HTML canvas is an obvious choice. I also have a bit of of experience building games on canvas. See Agent 8 Ball and our work for Ze Frank.

Darts on Canvas

The working version of Dartsweeper does all of its drawing and click handeling via canvas. Canvas is an immediate mode graphics API. It's simple and straight-forward. It's also easy to have code complexity blow up once you start building anything complex.

When I was building out the UI layer for Throwing Stars for Mr. Frank, I wanted an object-oriented way to think about game elements. I wanted a star object and a wall object and a coin object that encapsulated the game physics and element rendering. So I put on my astronaut suit and built the PL javascript library. PL is short for Pixel Lab.

A big chunk of PL is under the retained namespace. It's a collection of types for retained mode graphics on canvas. I've ported most of the retained libraries to my dartlib project and they are used heavily in Sweeper.

Retained mode with Dartlib

I'll probably do a video at some point about the retained model in dartlib. The short version:

Stage: The glue between the DOM (a HTML Canvas element) and a root "element" in the retained world.
PElement: The base class for visual elements in the retained world.

Drawing is done with CanvasRenderContext2d. Super simple.

Zero or more transforms, which allow layout by the parent and fun effects
Parent and child pointers

Allow hit testing and mouse interaction

The P prefix stands for Pixel Lab. I'm trying to avoid naming conflicts with Element.

There's a bunch of other magic here, too. Mouse support. An attached property and attached event model. Support for correct Click behavior (mouse down the mouse up on the same element). Check out the samples in dartlib.

If you're feeling really adventurous, take a look at vote.dart. I have a lot of fun with retained graphics.

Issues

Cross-browser confusion

I've run into a couple of issues when trying to play the JS-compiled version of Dartsweeper on Firefox.

In one case, I was using a webkit-specific version of requestAnimationFrame which doesn't exist on FireFox. Thankfully, Seth pointer me to the un-prefixed version of the API that works everywhere. A bug is open to removed the webkit prefixes.

In another case I discovered MouseEvent.offset[X|Y] don't exist in FireFox. There is a bug on this, too. I added a helper to dartlib provide the same functionality.

Growing pains with pub

I'm started tip-toeing into pub by migrating unit test code away from the copy in dartlib (which has been removed) to the SDK version.

Setting up pub has caused me a bit of stress since I use a custom homebrew formula to keep my SDK updated. Pub needs the DART_SDK environment variable to be set and homebrew installs versions in directories based on the version number. This causes a bit of headache as I need to delete the packages directory and rerun pub install every time I update my copy of Dart.

It's a bit of a headache, but it's purely related to how I install Dart. I'm hoping to tweak the homebrew formula to resolve this issue soon.

Next Steps

All of the work to migrate the game to canvas would be a bit silly if the output still looks like a poorly styled table.

After I finish up work storing high scores and created a touch-enabled interaction model, I'm going to jump into custom graphics, animation, and sound.

I'm excited. Stay tuned.

Oh, and you can help

All of the code is on github. File issues. Fork and add features. I'd love collaborators.

If you'd be interested in doing a hangout to discuss my graphics model, let me know.

Cheers.

Are you ready to bet on the Web? Let's talk.

2012-08-20T23:33:00.001Z

Are you maintaining a legacy applications written in VB6? Windows Forms? Java?
Are you relying on ActiveX and outdated browsers?
Are you unsure how to support new devices, new form factors, and new platforms?

Do you have a Web presence, but lack a Web mindset?

Let's talk.

As a consultant, I have had the opportunity to work on a lot of different projects and platforms.

Big enterprise apps with .NET.
Fun and engaging apps for iOS.

Beautiful games with Javascript and HTML5.

I've had pretty good luck having interesting work find me.

Now I'm turning the tables.

I've learned a lot building frameworks and applications both using enterprise development technologies that target a single platform and open source tools and technologies that target the standards-based Web.

I want to help bring tools and methodologies used by leading-edge companies and startups to organizations that feel stuck and left behind.

Is that you?

Does your an organization want to cross the chasm?

Let's talk.

Dartsweeper: Dev Journal 1

2012-08-16T18:16:00.001Z

tl;dr: I'm building a version of Minesweeper in Dart as an example of something straight-forward and fun. I hope to show how to build Dart apps and demonstrate why Dart is a great tool for building web experiences. Play it here. Check out the code on Github. Watch my blog for updates in the next few weeks.

Intro

I'm having a lot of fun with Dart. It's a great intersection of the things I love about other platforms.

The open source goodness of Ruby and Python.
The type goodness of C# and Java--which lights up a productive IDE development experience.
The run everywhere goodness of Javascript.

I've built a couple projects in Dart, but I wanted to build something for newbies.

Getting the Code

Dartsweeper uses my Dartlib library. I haven't quite migrated Dartlib to pub. If you want to play with the code, make sure you download (or git clone) both the code for Dartsweeper and Dartlib and put them in adjacent directories.

source_code

sweeper.dart

lib
html
readme.md (for sweeper)
...

dartlib

bin
docs
readme.md (for dartlib)
...

If you're using Dart Editor, which I recommend, open both directories to see all of the code.

Approach

Honestly, I'm a bit confused and tired of the whole MVVMVPMVC discussion.

Let me put my approach simply: Separation of Concern (SOC). Build small pieces that do a small set of things and connect them in clean ways. It enables easy unit testing. It enables flexible architecture. It avoids bike shedding about what's the V or the C or the VM or the P.

The other acronym I'll hang my hat on: TDD. Test-driven development is amazing generally, but especially for games. Games often have states that take a while to get to--like winning. Games that have random state--like Dartsweeper--can also suffer from obscure edge casses that one can only find by playing a lot.

It ends up being much easier to just point a unit test at a Game object and have it hammer through a large number of game states.

But I'm getting ahead of myself. Follow along in the lib directory in the repo.

lib/sweeper directory

Main logic of the game. Nothing UI-specific.

Field: The read-only, 2-D collection of squares. Booleans. True if it's a mine. Also exposes the adjacent count to make rendering numbers easy.
Game: The core logic. Tracks the state of the game. Allows revealing and flagging. Exposes the duration of the game.
GameState and SquareState: enum-like classes for recording the state of the game or individual squares

Take a look at the associated unit tests. Dart advertises itself as "batteries included". An example: the core libraries include a really nice unit test framework.

lib/html

The HTML version of the game.

GameView: Populates the provided DOM elements and wires up event handles.

html

Where you actual application exists.

sweeper_demo.dart: A tiny bit of code that imports the game logic and the html logic, finds the target elements in the page, and creates the GameView.
index.html: Defines the elements for the app. Aside from a couple of special script tags, it's just HTML, which is the point.
style.css: Just styles. Nothing special.

Experience

So far I haven't hit many big issues with the app. It's a joy to work in an IDE with a typed language.

I'm much less scared about refactoring code in Dart because I get warnings if I've forgotten to rename a variable or if I'm missing an argument to a method. Not only does the type system make initial development faster (with features like member completion), it makes code maintenance easier. This is a huge win.

Being able to debug Dart source directly (instead of generated javascript) also greatly improves productivity.

I have hit a couple of bumps, though.

Issues

Compiled Javascript size

It's huge. Far bigger than the source Dart code in my project. It's been the source of mockery on Hacker News, etc.

While it's a bit annoying now, I'm not worried. At the moment, compiler processes all of the imported libraries (even the code that's not used) and generates output that's not minified. Tools like the Closure Compiler have shown this a solved problem. The Dart team is worried about stability and correctness now, as they should. I'm patient.

Minor cross-browser issues

I was using MouseEvent.toElement, which is not supported in FireFox. I moved to MouseEvent.currentTarget and everything now works. This is a case where having the uncompressed javascript output was a good thing. It was debug the output to find the problem.

Future

Canvas, sound, mobile. I already have a nice set of retained graphics libraries in Dartlib. I going to dive in with animations and the Web Audio API. I'll keep the existing HTML app in place, since it's such a straight-forward sample. Once I figure out a clean interaction model, I also hope to make Dartsweeper sing on phones and tables.

I'm excited to see how much I can light up this app with Dart.

Stay tuned.

QR Code Generation in Dart

2012-07-21T04:25:00.000Z

I've ported the QR Code logic from my pl javascript library into dartlib. I don't have funky animations yet, but:

The QR Code is generated off-thread using isolates.
It compiles to Javascript. ~9,000 lines worth.
The JS version seems to work fine in Chrome, but not Firefox or Safari.

The conversion was pretty straight forward. Types in Dart make debugging this type of code so much easier. Isolates make it easy to keep CPU-intensive tasks (like generating QR codes) from slowing down your UI.

Cool.

Getting Git - Feb 23 - Buy Tickets Now

2012-02-17T22:39:00.000Z

tl;dr: Go to this form and donate $20 to an amazing cause. Show up at Office Nomads on Thursday, Feb 23 at 6:30pm. Learn Git.

What: a workshop to get people productive with Git.

Why:

Git is an amazing tool to manage and collaborate on text content -- source code, html, javascript, etc.
Giving money to United Republic is a great way to get involved in the political process and fight the influence of money in our democracy.

Where:

Office Nomads
1617 Boylston Ave, Seattle, WA 98122

When:

Thursday, Feb 23, 2012.
6:30pm.
Doors open at 6:15.
We'll start right at 6:30. Don't be late.

How much: $20. Donate here.

What to bring:

Your laptop.

Windows - install Git Extensions. Use the latest "Setup Complete"
Mac

If you don't already have HomeBrew or MacPorts installed, install Git from here.
If you do have HomeBrew or MacPorts, I'll help you get going when you get here.

Linux

I'm sure you can figure it out.

A GitHub account. Free. Easy.
Note taking materials. Your favorite text editor or a pen and paper.

If you have questions, email me.

See you on Thursday!

Geeking for Democracy

2012-02-10T19:01:00.000Z

tl;dr: Fill out this form. Contribute to a great cause. Learn that thing you've been putting off.

A year and change ago I did a Getting Git workshop at my coworker spot in Seattle, Office Nomads.

Getting bootstrapped--self-sufficient--on new technologies is tough, especially if you don't have a good relationship with someone experienced. Conferences and user groups can be intimidating and rarely offer opportunities to dig in from the beginning--especially for more than the length of a 50-minute presentation.

I've learned a lot of fun technology since I left Microsoft 5 years ago--has it been that long?--in no small part because people in the know were kind enough to show me the way.

There are three pieces of tech I love showing people and I feel--at least compared to beginners--I can offer a great starting point:

Git
Ruby on Rails
Google Closure Compiler and Libraries - used to build Agent 008 Ball, among other things at Pixel Lab.

Fill out this form. Once I find a sweet spot of interest, I'm going to schedule a workshop. A weeknight or a weekend morning/afternoon in Capitol Hill (Seattle).

The price of admission? A donation to United Republic -- a group dedicated to getting money out of politics.

You get to learn some great tech and we both get a warm fuzzy helping out a great organization.

In case you missed it: Lot's of Bag 'o Tricks fun recently

2011-07-21T18:46:00.000Z

My main gig has been all Silverlight all the time over the last many moons. I've pushed a lot of changes to the Bag 'o Tricks in response.

I've also added the BOT to NuGet.

Here's a lazy man's update--just a copy-paste from the changelog.

Take a look.

Bag of Tricks Change Log

V4.1.0 - 2011-07-20

Lot's of fun now stuff, but no breaking changes! Feels good.

Added GetStringComparer extension that takes a CultureInfo
Added SelectAdjacentPairs to extensions
Added ResourceHelpers extensions to SL assembly
Added TryGetTypedValue<> extension
Fixed a gnarly bug in SL version of ColorHelper.HsbToRgb
Added NextFloat extension method for Random
Added ModalControl Closes #23
Adjacent pairs methods now take IEnumerable<T> instead of requiring IList<T>

v4.0.0 - 2011-07-08

BREAKING - Removed DispatcherExtensions. The implementation was trivial and it brought in all of Reactive Extensions as a dependency, which isn't worth it.
Fix for Issue #3 from Larry.

v3.0.0 - 2011-07-08

Because this rev contains non-compatible breaking changes, I'm bumping the version number. If this is annoying, let me know and I'll be more careful.

Added command support to DoubleClickBehavior - thanks, Larry
Added demo for DoubleClickBehavior
Added FilteredObservableEnumerable
BREAKING - Using Reactive Extensions for async features

v2.0.0 - 2011-07-05

In the NuGet world, BOT is not three projects: Core, Common, BOT. This allows one to minimize dependencies on external assemblies (mostly Prism) when not needed.

BREAKING - Added a Core Silverlight assembly to match the same in WPF
BREAKING - Moved DemoCollection back to WPF demo app. This eliminates the dependency on Prism in Core and Common

v1.1.0 - 2011-06-22

Moving to Semantic Versioning. Non-breaking features are added, so we bump minor version number.

Library changes

Added Insert method to WeakEnumerable<T>, which puts new items at the beginning of the enumeration. Which makes insertion O(1) instead of O(n)
Added SortedObservableEnumerable<T>: because sometimes you'd like a sorted view of an INotifyCollectionChange
Added Synchronize extension method. For those times you want to update an OCP with a source collection and a factory

Non-library changes

Fixed the WPF demo around property watcher
Removed Phone from the main solution (since it remains broken)
Added another layer of directories to builds, so there are no longer collisions between Silverlight and WPF build outputs

v1.0.6

Added support for critical inner exceptions to IsCritical
Moved DispatcherExtensions methods to use SynchronizationContext, which is more general
- Should likely rename the class to SynchronizationContextExtensions, huh?
Naming and param order changes to PropertyChangeWatcher - Breaking Change
Clean-up in the SL test project
Added test for PropertyChangeWatcher

v1.0.5

A mountain of changes to ObservableCollectionPlus<T>
- Added Reset method - Closes #21
- Made sort methods safe - Closes #22
- Added MultiUpdateActive
- Changed the location of the call to protected AfterMultiUpdate to before raising reset

v1.0.4

A mountain of clean-up in demo and test code
Added WatchProperty extension method to Extensions
NEW PropertyChangeWatcher - Issue #16
Added some usage details to InstanceFactory
Added Util.ThrowUnless
Extensions.GetCustomAttributes -> change param MemberInfo to more generic ICustomAttributeProvider - Issue #19
Added AddRange to ObservableCollectionPlus<T> - Issues # 17
Some work to get Windows Phone 7 projects to load, although I've hit a snag with sharing generic.xaml between SL4 and Phone - progress towards Issue #18

v1.0.3

Much smarter implementation of Util.GetHashCode
Added ClearErrors to DataErrorHelper
Moved the targets files
Removed [DataContract] from Changeable - and cried that serialization support in Silverlight wasn't more flexible
AsyncValue: added LoadCommand property and LoadError event - Closes #10

Uninstalling Rails beta–with crazy bash tricks

2010-10-22T19:46:00.001Z

I'm know I could have done this by hand way faster than it took me to figure out.

I’m sure there are better ways to do this than I figured out below.

But still enjoyed figuring it out.

Scenario:
Uninstall all gems with version 3.0.0.beta4. These map to one of the last Rails 3 betas.
…and do it in one bash command.

This is what I ended up with.

gem list | grep beta4 | awk '{print $1}' | xargs gem uninstall -v=3.0.0.beta4

gem list – lists all installed gems
grep beta4 – filters the output to lines containing ‘beta4’
awk ‘{print $1'}’ – takes each line and outputs only the gem name (not the version info)
xargs – takes the last output and appends it to the given command: gem uninstall -v=3.0.0.beta4

Cool, huh?

Well, if you know bash, maybe not. I’d love to see a “better” version of this.

MSBuild and Custom Targets: Almost too much fun

2010-10-15T16:47:00.001Z

I’m a big believer in DRY – Don’t Repeat Yourself – in software.

While I try hard to practice this in the code for the Bag of Tricks (BOT), until recently I’ve ignored my project files.

VS handles that, right?

Well, kind.

It turns out there is a lot of duplication in proj files. Every one defines constants and output paths. If you’re using Code Contracts, you get a bunch of contract properties all over – sometimes differing in inexplicable ways between debug and release.

I got sick of it. I cleaned it up.

BuildShared.targets – Shared state across every project. Warning levels, shared build constants, even output path.
- This is great. If I want to change the location of obj and bin, I just change one file now. Super nice.
Contracts.targets – This defines all of the Code Contracts build parameters.
WPF4, SL4, WP7.targets – Common code for a given platform. Things like target framework, framework profile, etc. (WPF and SL include Contracts, Phone dosen’t.)
Now each proj file includes the associated platform proj file and just sets project-specific properties.
- Guids, OutputType (library or exe), root namespace, assembly name, etc.

The downside: if you go hack specific properties via VS, you’ll add a bunch of one-off changes to individual proj files.

…but this is why we use source control, right? I can look at the diffs and ask: are these changes I want to share across projects or things I can just throw-away?

And having all of the shared noise in another place makes parsing the proj file a lot faster.

Take a look at the code. All of the targets are in PixelLab.Common\_targets. (Yeah, a weird place. I’ll explain later.)

Happy hacking.

Bag of Tricks on Github: How and Why

2010-10-14T16:50:00.001Z

On October 7, I updated the Bag of Tricks CodePlex site:

Active development for BOT has moved to GitHub.

Don’t Panic! (You can still use Subversion)

I’m super happy folks like using the BOT. I don’t want to stop you.

You can still download the source as a zip. Just click download on the GitHub page.

And you can still use Subversion (SVN). GitHub has done the wonderful work of enabling SVN via HTTP. Point Tortoise (or your other favorite client) at http://svn.github.com/thinkpixellab/bot. Super easy.

Reason: Git vs SVN

I could rant a long time, but I’ll just point you here: http://whygitisbetterthanx.com/#svn

The short version:

Easy to work locally. Which is something you likely won’t comprehend until you do it. Saving a bunch of small changes locally before a big push to the server is really nice.
Easy to branch. On the server. Locally. It’s all easy. It’s all scary fast, too. No copying a bunch of identical files.
Scary fast. I can’t emphasize this enough. Wow. It’s just really fast. Everything. Pushing, Pulling, Committing, Branching. Amazing.

Reason: GitHub vs CodePlex

Faster. GitHub is just way faster. It probably has a lot to do with the benefits of Git.
Better Tools. Better for looking at changes, commenting on commits, etc.
Way less annoying. I frequently have crazy issues on CodePlex. Commits fail for weird reasons. Updates don’t update everything. I’m sick of it. Never had such problems on GitHub.

Reason: Logistics

Rails. I do a lot of work with Rails. The Rails universe is all on Git and GitHub.
I think in Git. It’s the tool I love. It’s the tool I use. I want to use it everywhere.
I live on GitHub. All of my projects – both open and closed – live on GitHub. I want to have one place to go.

Jump on in. The Git is fine.

It’s more than fine. It’s awesome.

Auto-discovering demos in the Bag of Tricks with MEF and System.Xaml

2010-09-29T18:22:00.001Z

Back in the old days (sometime in 2005) I built out the Bag of Tricks. At the time, the index of the samples was stored in an XML file. I then used data binding to to connect to the XML, show the items and the descriptions, navigate to the page URLs.

It was very cool…kinda…

Then MEF came along and I realized that having a secondary list of each demo was a bit broken. Each demo should describe itself, right? So I MEF-ized all of the demos that had custom classes by annotating the classes with custom metadata.

It was very cool…but…

I had a bunch of demos that were Xaml-only. Just pages of Xaml that did their thing.

I started the process of creating classes for a bunch of them, but that felt broken. Pages are just xaml. I should be able to use attached properties on each page to specify demo metadata.

Thanks to the work of the Xaml team at MS, we got it done. (Thanks for the email support, Rob.)

Now BOT samples for both Silverlight and WPF use the same mechanism to load samples—although the WPF version gets special support for Xaml-only pages.

Download the latest code on the Source Code page on BOT’s home on Codeplex.

Getting ‘git’: lunch workshop on Cap Hill, Oct 5

2010-09-23T21:39:00.001Z

Update: RSVP here.

I love git. Really, really love git. I’ve used SVN and PerForce. They don’t come close.
Some folks here at Office Nomads have asked me to give a talk. I figured I’d open it up to the public.
Details:

Location: Office Nomads, 2nd Floor, 1617 Boylston, Seattle.
When: Noon to 2pm, October 5, 2010
Cost: Proof of a $25 donation to EFF or Fix Congress First. (If you’re tight on cash, let’s talk.)

I’d suggest watching one or both of these videos are prerequisites:

The original Getting Git introduction by Scott Chacon.
From the man himself, Linus being hilarious talking about the why and how of git.

Before you come you should also:

Create a free account on github.
Install software for your machine:

Windows: go with Git Extensions. Pick the 203 “complete” release. Should integrate nicely into Visual Studio, too.
Mac:

Command line

If you use Mac Ports or another package manager, use that to get the latest git (1.7*)
Otherwise, install from here. (I use MacPorts, so I have no clue how this works)

GitX experimental branch. See the link to 3.0.3 at the very top of the page.

Linux

You don’t need my help…

If you have problems with install, tweet me a help request.

Physics for Agent 8 Ball - box2d

2010-09-15T18:22:00.000Z

I don't have a lot of time to write, since I'm actually at the launch event, but I wanted to share a quick note about the plumbing of Agent 8 Ball. Check out http://box2d.thinkpixellab.com/ to see how we made our pool game come alive.

bundle_view is now "bundle viz"

2010-05-17T18:19:00.000Z

Last weekend I tweeted:

My weekend #ruby hacking. GraphViz for your #rails Gemfile using @gembundler. http://bit.ly/b1PaXT Suggestions, patches welcome!

What a fun week it's been.
@wycats hunted me down and asked if I'd roll bundle_view into bundler.

Update: Made it into bundler. See the commits here.

CLI on the Web? Sure, but put x86 their first

2010-05-03T22:08:00.001Z

Miguel blogged a great idea today, expanding on Joe Hewitt’s simple statement on Twitter:

If CLI was the ECMA standard baked into browsers instead of ECMAScript we'd have a much more flexible web.

Agreed. I’d love to be able to run C# instead of Javascript on my web page. I’d also love to be able to run Ruby. Or even Scala. So why not JVM on the Web? What about Go?

Why not indeed. If there is going to be a push to have broader language support on the web, let’s jump over the problem of picking the right VM and Garbage collector. Let’s skip shared agreement on compatibilities between Microsoft’s implementation and Miguel’s.

Let’s go straight to Native Client.

I’ve talked about Native Client before. Here’s the official summary:

Native Client is an open-source technology for running native code in web applications, with the goal of maintaining the browser neutrality, OS portability, and safety that people expect from web apps. We've released this project at an early stage to get feedback from the open-source community. We believe that Native Client technology will help web developers to create richer and more dynamic browser-based applications.

Native Client runs on 32-bit x86 systems that use Windows, Vista, Mac OS X, or Linux. Some ARM and x86-64 support is implemented in the source base, and we hope to make it available for application developers later this year.

Instead of worrying about Mono or Microsoft worrying about getting the sandbox right for the browser, let’s solve it once.

Then I can target the C# with the Mono CLI.

Or IronPython with the Microsoft CLR.

Or Ruby with JRuby. Or just MRI, if I want.

I’m certainly waving my hands over a lot of technical details. I know.

My thought is simply this: CLI as another Javascript is radical idea.

Perhaps just not radical enough.

Bag of Tricks Update (two years in the making)

2010-04-07T05:50:00.001Z

Has it really been two years since the last official update of the Bag of Tricks?

I guess it has. A lot has changed since then. I started my own consulting company. And then joined up with Robby to launch Pixel Lab.

With previous releases, I was doing a very good job of breaking out almost all of the changes. This time, there are just too many. I’ll try to highlight the big ones.

Added Org Tree. This is a pretty straight-forward sample of a vertical tree view.
Added ReorderListBox. This is something Robby’s had for a while. I cleaned it up a bit for reuse.
Added Show
Removed the date controls. There are better versions in the official WPF Codeplex site.
Created AnimatingPanel abstract class. This is now the base class for AnimatingTilePanel and TreeMapPanel. All you have to tweak is call the protected virtual ArrangeChild in ArrangeOverride.
A bunch of additions to the Common assembly.
Moved main development over to VS 2010.
Added support for Silverlight 4. You’ll find projects nested in the same folder. You’ll also notice #define #if #else for SILVERLIGHT which handles some special cases where things don’t work in both places.
Added Vector for Silverlight. This allows a bunch of my helper methods and animation methods to work without code changes between the two frameworks.
Added ObservableCollectionPlus<T>. This has a ReadOnly property, along with support for Sort and adds Move to Silverlight OC<T>.
…and a bunch of other stuff I’m likely forgetting.

You can get the source (via SVN) at Codeplex: http://bot.codeplex.com/

You can download a sample app that runs against WPF 3.5 here.

The BOT has been the basis for Silverlight, WPF, and Windows Phone 7 apps I’ve written this year. Robby and I are going to keep tweaking it and updating it as we need new stuff.

You should do the same.

File bugs. Submit patches.

Let’s make this our Bag of Tricks.

Happy hacking,

>Kevin

PS -> please make comments on the codeplex project discussion page! It's much easier to reply there. :-)

Google's Native Client belongs on the Server, too

2010-01-24T20:14:00.001Z

What is Native Client?

Have you heard of Native Client (NaCl) from Google? Yet another open-source client software play from our overlords in Mountainview.

The write-up on the project site is pretty good:

Native Client is an open-source technology for running native code in web applications, with the goal of maintaining the browser neutrality, OS portability, and safety that people expect from web apps. We've released this project at an early stage to get feedback from the open-source community. We believe that Native Client technology will help web developers to create richer and more dynamic browser-based applications.

Think of it this way:

Right now, the only way to play with the HTML DOM is with Javascript--Javascript with a surface area explicitly limited to the DOM.

Now imagine you could give any x86 the same explicit sandbox--with some clever run-type verification.

While we should all be worried about claims of safety, the promise of high-performance and language agnosticism is tempting.

Forget the CLR and the JVM.
x86 won a long time ago.

Now App Engine, Please

If Google really buys into the safety of NaCl, they should put their data center where their mouth is.

They've done a lot of work to provide Python and Java support on App Engine. Why not allow any language on App Engine with NaCl?

Instead HTML DOM being the "safe" surface area, make it HTTP request/response. Think CGI or (as a Ruby guy) Rack--expanded, certainly, for background tasks, datastore/memcache access, email, etc.

A revolution in back-end web programming

There's a painful gap between ease and flexibility on the backend.

Sandbox too Small

If you want ease, you're stuck with a limited "approved stack" at a host--Java/Python on App Engine, PHP/Rails at Dreamhost, etc.

You're stuck with Ruby 1.8.6 at Heroku. You're waiting for Google to support Python 3.0 on App Engine.

Sandbox too Big

If you want flexibility, you're stuck managing a Linux image on Amazon EC2 or Slicehost.

You have to worry about which Linux distro to run...if/when you should patch it.

Not to mention giving up all of the smart scaling one gets from App Engine-like solutions.

Sandbox just right

We need an abstraction layer that fills the gap.

NaCl seems like it would fit the bill.

Google could re-write their Python and Java sandboxes for App Engine to run within NaCl. At this point I'd wager, any language/framework--Ruby/Rails, PHP, or even old-school Perl/CGI could be tweaked to run there, too.

Google could open-source this sandbox, no doubt, providing a de facto, language-agnostic web server model.

Which sounds really nice to me.

Shipping Microsoft Singularity

Our friends in Redmond have been playing with the idea of allowing safe execution of 3rd-party code.

A research project called Singularity aims to allow high-performance and safety...but it feels like the all too common "boil the ocean" play from Microsoft. New tools, new languages, and a new operating system.

It's a project that's been public for 5 years, with little more than some channel9 videos to show for it. I fear we'll see a lot more research papers before we see any production-approved code.

Google's model with NaCl--"let's make x86 safe"--is ambitious, but tightly constrained. It also piggy-backs on a huge stack of open-source languages, frameworks and tools.

Native Client could be huge.
Huge in the browser.
Just as huge on the server.

Tweet This!

Thoughts on Google's client software strategy

2009-12-21T06:02:00.000Z

We’d all like a peek inside the mind of Eric Schmidt—beyond just understanding what he’s wearing in his twitter profile picture. Search and maps and profiles: these all make sense. But there are a set projects that Google has been putting out lately that don't fit. They're open source and focused on the client machine.

A browser.
An operating system.
An extension to HTTP - SPDY.
An drastic evolution of AJAX - Web Sockets.
A public DNS service.
A drastic evolution in web programming - Native Client.

Some of these are put under the banner of "making the web faster".

Let me go a step further.

Google makes lots of money when you're clicking. The faster and more efficiently you consume their experiences, the more you click. The more you click, the more money Google makes.

But there are bumps along the way.

Crappy ISPs

Out-dated operating system.

Outdated and/or bloated browsers, protocols, and programming languages.

Google was silent on these for a long time--pushing existing technologies in novel or extreme ways--AJAX with Google Maps, Java Web Toolkit for Javascript, even shoe-horning Chrome into IE.

In the end, the've decided to cut out the middle man.

Ponder the stack of technology between you and Google's web offerings. When Eric Schmidt thinks about protocols, operating systems, and browsers--he has the same thoughts as Bill Gates did 20 years ago--about disk drives, CPUs and RAM.

Make them solid. Make them better.

But keep them out of the competitive picture.

Commoditize.

MSFT did it riding a wave of cheap PCs.

GOOG is doing it by riding a wave of free software.

Tomorrow. Seattle. Have a Mac? Wanna learn Rails?

2009-12-17T08:47:00.000Z

I had a friend ask me if I'd be willing to teach him Rails. I said sure. Then I got to thinking: what would it take? Take a code-savvy person and teach them enough Git and Ruby and ActiveRecord to get them moving.

So I'm going to try it on Friday. Maybe just with Donald, but if anyone else wants to join us on Capitol Hill in Seattle, you're welcome.

Requirements:

Have done some coding.
Have some experience with web sites, HTML, etc.
Have a Mac.
Free on Friday, Dec 18, in the afternoon.
The catch: you must bring proof of at least a $50 donation to the EFF, Creative Commons, or WikiMedia. (If you're in a tight spot, we can talk.)

Drop me an email at ror4aday (at) j832 (dot) com if you're interested. I might do something slightly more formal in January, too.

See you on Friday.

Goole and reCaptcha: expanding Google's Cloud Brain

2009-09-16T17:27:00.000Z

You've heard of Google Translate, right?

You know how it works? It learns:

Our system takes a different approach: we feed the computer billions of words of text, both monolingual text in the target language, and aligned text consisting of examples of human translations between the languages. We then apply statistical learning techniques to build a translation model. We've achieved very good results in research evaluations.

Heard of Google 411? Why would Google get into the 411 business? So it can learn. Read:

So we need a lot of people talking, saying things so that we can ultimately train off of that. ... So 1-800-GOOG-411 is about that: Getting a bunch of different speech samples so that when you call up or we're trying to get the voice out of video, we can do it with high accuracy.

So Google bought reCaptcha? Why? I'm betting it's the same reason.

It's not about finding one translation problem with one blurry word and fixing it. It's about learning how to read any and all blurry words. So it'll need humans to intervene less and less.

This is pure brilliance on Google's part: humans providing input--doing valuable work--and getting a valuable service.

And Mountain View silently reaps massive amounts of intelligence.

Google is throwing a lot of code over the fence--Java libraries, Chrome, Android--mocking the business model of traditional software companies.

And they don't care. Because in the end, they have a world-class, next-to-impossible-to-replicate cloud brain.

And it's getting smarter with every search, every new web page, every Goo411 call, and now, every new "You're a human, right?" verification.

Cool...and a bit scary.

RightZoom - Windows Maximize on Mac - Almost

2009-07-09T19:58:00.001Z

I was looking for a maximize solution on my Mac that felt more like, well, Windows. RightZoom (almost) gets it.

Best feature: keyboard shortcut. I can just mash down on Ctrl+Alt+Command+M and maximize a window. Boom. Awesome. (See below.)

Worst issue: causes weirdness of windows when I'm multi-mon. Only on my smaller window, which is fine.

Check it out.

Search keywords in Firefox rock!

2009-07-03T17:56:00.001Z

I just found a twitter search plugin for Firefox. Cool.

As many know, your non-default search providers show up by clicking a drop-down by the search box. At the bottom of this drop-down, you'll notice Manage Search Engines... link.

Click it. You'll see this.

Notice the keyword column? Notice the Edit Keyword... button? WTF?

This Mozilla KB article explains it.

See the keywords I added above.

Typing "w Iowa" searches Wikipedia for Iowa.

Typing "t health care" searches twitter for health care.

Sweet!

Parsing JSON with Unicode in Ruby and Rails

2008-12-27T23:22:00.001Z

As I've done twice before, I'm going to try to save someone else a couple of hours of hair pulling.

I'm playing with some RESTful web services with a rails app as the client. The service returns JSON.

Cool.

As defined in the spec, JSON strings may contain Unicode characters escaped as '\u four-hex-digits'.

Let's say you had a JSON result with xml, like {"value":"<xml/>"}.

The service might return {"value":"\u003cxml/\u003e"}.

That's fine, except the default JSON parser in rails--ActiveSupport::JSON--doesn't (yet?) support unescaping the Unicode characters.

Boo!

A blog post pointed me to the stand-alone JSON rails gem.

That solved my problem.

Happy hacking, my friends.

20 questions/thoughts around MGrammar

2008-11-25T22:48:00.001Z

I had a great time attending the PDC virtually. Azure, C#, Xaml—these all were cool. The tech I was most excited about was Oslo, specifically building custom DSLs with MGrammar.

Having spent a lot of time in Xaml and C# at Microsoft and migrating to a world of Ruby and JavaScript and HTML/CSS and HAML/SASS, I've had my hands in a lot of tools. And I have lots of questions and thoughts for the community. And, specifically, Chris, Don, Doug, Pinky, and the gang.

When I talk about a 'logical', I'm talking about MSchema in Oslo terminology--at least I think so.

Where is the MGrammar for C#?
…for VB?
…for CSV?
…for VS Solution files?
…for XML?
Could C#/VB implement their compilers using MGrammar? Should they? Would they?
- I’m imagining the tools I could write if I had the grammar…and could insert myself in pre-compile stage. Awesome.
- What an amazing better-together with C#'s new compiler-as-service.
There should be standardized or defacto escape mechanisms for existing grammars.
- "If you want to inject your own magic into [C#|VB|XML|etc] use this (relatively) safe/constrained notation."
- I'm thinking about a subset of SASS markup for WPF styles that I could in-line in XAML and have processed at build-time.
Could the MGrammar for XAML just party off the MGrammar for XML?
…could it be written without referring to 'physical' XML, and instead just refer to the XML MSchema model?
If I had a MGrammar for HAML that could generate most of ‘logical’ XML, could I then 'infer' the 'XAML in HAML' using #9?
Will there be tools to go back from a logical model (MSchema) to the input format? I'd like to store data in a logical model, but be able to allow editing via the text format.
How about tools that allow the comparison of two grammars to see if they generate the same MSchema--perhaps with different labels. Perhaps with the ability to convert between them. Perhaps with the ability to identify strict sub- or super-set grammars.
Where is the community site for MGrammar?
- User-submitted grammars
- User submitted and verified 'tests' against the grammars
- Easy tracking of new (and old) versions
- Easy tracking of forked/related grammars
Want to have MGrammars.com? I registered it for Microsoft. I'll give it to ya'll for free. Just promise to make a great community site.
I'll even build the site for you. It'll give me an excuse to use Azure. I'm happy to offer my consulting services.
Any news with Mono? Is Miguel interested?
Are you making a play to make MGrammar a standard? I've heard yes, but just wanted to confirm.
How is the computer science behind MGrammar? Is it as good/better than existing tools? BNF? Lex/Yacc? Others? Is there a write-up? I'd love to see where MGrammar is pushing the state-of-the-art.
Anyone pushing a normalized Wiki grammar? Like this? Yes, a weird point, but think of how much IQ in the world is stored in Wikipedia and it's next to impossible to parse because MediaWiki format has a bunch of random PHP parsing quirks. A great intern project.
As you can tell, super excited about the project, guys. Keep it up.

Props to Silverlight CLR team: My Common DLL Just Works FTMP

2008-11-21T09:17:00.001Z

FTMP = For the most part

In Visual Web Developer 2008 Express Edition SP1 .NET XP Live.

I created a new Silverlight control library, under my public SVN location.
I did the right-click ‘Add Existing Item...’ trick.
I navigated to J832.Common and added all of the CS files (except DBUtil and ReaderWriterLockHelper).
And I hit build and watch it compile.

The result is a very boring looking directory with great potential: I can now use all of my common tricks in Silverlight, too.

You know, if I happen to be working on something in Silverlight. Hypothetically.

First Project Shipped: What A Lovely Name

2008-11-17T20:43:00.000Z

It's official.

After an amazing first collaboration with my friends at Jackson Fish Market, What A Lovely Name has launched.

Thanks to...

Jenny - what an amazing designer. It was an honor just to be able to set her graphics as div backgrounds.
Walter - in a word, brilliant. Turned hours of hacking into moments of enlightenment. He's made me a better [ruby|javascript|css|*nix] hacker and a better engineer.
Hillel convinced me to leave a comfortable job at an insurance company and start my own gig--with a story about half-priced pots. I'm not kidding. I'm not sure I would have done it without his encouragement--or prodding. Looking back over what I've done and what I've learned over the last 4+ months, I couldn't be more grateful.

Also thanks to...

MacBook Pro for being an amazing piece of hardware, even if it's not the new one.
Ruby and Ruby on Rails for challenging my sole devotion to statically typed and compiled languages
APIDock for being a great Rails reference.
Haml and Sass for making HTML and CSS fun
Prototype and script.aculo.us for some amazing Javascript tools
ImageMagick for server-side dynamic image generation
ssh - I now know how people on Unix get things done
git (and for a while Subversion) for version control.
pngcrush for making small pngs
Capistrano for making deployment easy
Mac Ports for making it scary easy to install unix tricks on a mac
Firebug for debugging everything. Amazing.
Firebox for having an extensibility story that supports things like Firebug
Safari for being more stable and more standards-compliant than Firefox a lot of the time
VMWare for letting me test IE7 compat without a Windows box
IE8 for emulating IE7 so nicely with something approaching reasonable dev tools
SliceHost for, well, hosting
TextMate for being an amazing editor
Skype and Adium for helping me stay in touch
Online Coffee Company for keeping me caffeinated

It's been a great ride. Can't wait for the next project.

ImageMagick, RMagick, Kerning, and baseline_shift

2008-10-29T19:51:00.000Z

As I said on Monday, at some point there has to be the first person to blog a useful tidbit in the world of software.

So, for the second time this week, let me be the first.

I've been using ImageMagick--via RMagick--to generate dynamic PNGs on the server.

In general, it's working great, except in one case.

I'm drawing text with custom fonts. The fonts have custom kerning.

ImageMagick seems to handle this fine except when one uses baseline_shift, at which point ImageMagick forgets everything about kerning.

You can fake the baseline shift by using get_type_metrics.

Again, here's hoping this saves someone 20 minutes...or in my case, a few hours.

Ruby, Rails, Render, and the Content-Type HTTP header

2008-10-27T18:58:00.000Z

Don't you hate it when you google for 30 minutes, trying to solve a simple problem, but for some reason the right combination of terms--or at least the combination of terms you think is right--fails.

It just happened to me with a simple problem: change the Content-Type HTTP Response Header for using standard Rails templates to be text/xml.

The solution is pretty straight-forward:

response.headers["Content-Type"] = 'text/xml'

...as I eventually found here.

Setting this hash value in your ActionController action method does the trick.

Here's hoping google picks this up and saves someone 20 minutes.

Fun with Google Maps and JavaScript

2008-10-25T06:49:00.000Z

In my last post, I mentioned some hacking with JavaScript.

While I've been finishing my first 'real' project for Jackson Fish Market, I've also been using my new knowledge of JS to dig into the Google Maps APIs.

My first sample is a simple location list. Type in an address (or just a city, zip, landmark) and hit 'Add location'. If the place can be found, it will be mapped and added to a list of locations. You can click on a location to go back to it or click on the 'X' to remove it.

Pretty simple, but also pretty cool.

And since this is the web, I don't have to post a zip file. 'View Source' will get you into see the magic.

Enjoy and happy hacking.

What I've been up to...

2008-09-03T05:01:00.000Z

I just realized that I haven't really posted since June.

For all of you still subscribed, I'm glad you're still hopeful I'll be blogging something interesting.

Here's a quick run-down of my (work) life the last couple of months.

Hacking a bunch of Ruby on Rails for a soon-to-be-released JFM experience.
Loving HAML and SASS for generating HTML and CSS in Rails.
Loving Prototype for coding Javascript--completely blown away what one can do with script. Loving blowing off a Flash component because it turns out JS+CSS is perfectly good.
Loving my Mac, mostly because it's UNIX.
Loving tweaking my bash shell--although considering moving to zsh.
Loving MacPorts for OSS installation.
Finally understanding and tweaking ipfw firewall settings with WaterRoof.
Loving TextMate, although I still need to learn more keyboard shortcuts.
Getting darn good at SVN, but really want to start using Git more often.

What I hope to be doing soon.

Coding some Silverlight. Maybe some controls?
Coding some Python, hopefully for Google App Engine.
Coding some stuff for iPhone. Maybe...
Moving my blog to a server I control--maybe WordPress--maybe something that runs on Rails. Who knows.
Working on some cool projects to improve democracy. Yes, random and vague. Hopefully I'll have more in a few months.

A lot of that will be on the back burner until I'm back from Europe. If any readers are in London, Oslo, Berlin, Munich, Paris or Cardiff, let me know. I'll be around mid-Sept to mid-October.

In the mean time and as always, happy hacking.

Robby is Free, too

2008-09-03T04:57:00.000Z

My good friend Robby--yes, check out that insanely hot Silverlight homepage--just announced he's leaving Identity Mine

Congrats on your freedom, my friend.

Yes, we need to get lunch this week.

I'm Free(lance)

2008-06-04T04:37:00.001Z

It's seems like only 8 month ago that I was leaving a job. It's just too much fun to switch around my insurance and investment plans, I guess.

I've had a great time at AMC. I proved to myself I can be happy being a developer full-time--something that worried me after five years as a program manager at Microsoft.

I'll miss working with Paul and David. Working day-to-day with David has been amazing. One of the hardest working and sweetest guys I know. He's made be a better developer and probably a better person.

What's next?

On June 16 I enter the wonderful, terrifyingly independent world of software consulting and freelancing.

My first gig will be helping out some good friends and former MS co-workers at Jackson Fish Market.

You'll hear all about the project when it's done. All I can say now: Ruby on Rails and a little Flash.

I can't wait to hear the comments about either leaving or go to the dark side.

Yes, I've been spending time at the Apple Store. Scary.

No, I'm not giving up the MS stack. I'm hoping to have the chance to do consulting and freelance work in WPF and Silverlight, too.

While I'm likely booked for over a month, I'll be looking for gig+1, +2, etc. shortly.

If you would like to chat about my services, please drop me an line: edeya9902(at)sneakemail(dot)com.

In the mean time, happy hacking.

iPhone 2 - Apple's entry into the console market

2008-06-03T20:33:00.001Z

Well, maybe not so much the console market as the console business model.

The $200 price tag has been thrown around a lot.

Can the device be this cheap to make? Maybe, but I doubt it matters.

It seems Apple is going for the two-headed revenue model of Xbox.

1) Get a slice off the service. Assuming the existing deal sticks around with AT&T and is copied in other countries, Apple gets a cut of the monthly phone service plan. ($18/month currently.) This is an even better deal for Apple than Xbox Live is for Microsoft. MS has to deal with the infrastructure and up time for their for-profit service. Apple leaves all of that grunt work to the carriers and still walks away with a fat check every month.

2) Charge app authors. There will be a flood of apps for iPhone 2. Apple gets 30% of the sale of all applications--similar to fees changes for XBox and PS. If initial excitement around iPhone apps holds up--even if it's just for games--Apple stands to make a lot of money.

Apples doesn't even have to break even on the hardware to come out ahead. That puts Steve Jobs in an amazing advantage over Blackberry and others who have to make their hardware generate profit from sales alone.

Brilliant.

In the end, I don't care. I'm happy with the money I've thrown down so far.

One request: add over-the-air calendar/contacts sync with Google.

I'll be the happiest man alive.

Rob Relyea doesn't hate my mom; Karsten?

2008-05-30T04:06:00.001Z

Search for "why does rob hate my mom". I love the internet.

In March, I called out Rob Relyea about his passive aggressive stance towards a wonderful high school librarian in Iowa.

He was kind enough to respond, but I've been lazy about the follow-up.

So now I redirect my indignation: what's the story, Karsten?

GMail feature request: help me keep track of replies.

2008-05-24T04:40:00.001Z

Scenario:

I sent out email to many people via BCC.
I get a bunch of replies to this email.
I want to reply in kind to these incoming messages, but GMail doesn't show which received messages I've replied to.

Suggestions:

Give the option of the standard threaded discussion via. While GMail's interface is better in most scenarios, there are cases where a tree is better.
At minimum, give some indication that I've replied to a message. With many messages stacked in a thread, I can't figure out which I've replied to and which I haven't.

You have until next Friday, or I'm going back to Hotmail.

I bet if I wait long enough, Microsoft will give me $.05 for every email I send.

Why I hate Frameworks: from hammer to "general-purpose tool-building factory factory factory"

2008-05-12T23:48:00.001Z

A recent discussion with a smart guy reminded me of an article I read years ago. I wanted to think I read it on Joel on Software. I wanted to think it had something to do with "hammer factories".

Google did the rest.

The write-up, Why I Hate Frameworks comes from Joel's discussion group. Written by Benji Smith.

"So, instead, we started selling schematic diagrams for hammer factories, enabling our clients to build their own hammer factories, custom engineered to manufacture only the kinds of hammers that they would actually need."

"Let me guess. You don't sell those anymore."

"Nope. Sure don't. As it turns out, people don't want to build an entire factory just to manufacture a couple of hammers. Leave the factory-building up to the factory-building experts, that's what I always say!!"

Like most good content on the internet, brilliant and hilarious.

License for the Bag-o-Tricks...uh...

2008-05-07T22:39:00.001Z

I might as well handles the two "90% issues" together.

A lot of people ask about the license for the bag-o-tricks.

Here's the story.

Most of the code in the bag-o-tricks was written while I was at Microsoft. I never took the time to formally license it while at Microsoft.

Given the type of code and how it's been released, I think it's more than safe to consider it under the Microsoft Public License.

I say "I think" because I'm not a lawyer and I'm not 100% sure how to deal with code that I wrote while at Microsoft--and therefor, technically, "owned" by Microsoft.

I'd bet $10 you won't get sued if you use it any way you see fit. But that's as far as I'll stick my neck out. Being on the other side of the fence from the MSFT legal department is a bit...uh...interesting.

Everything that's new since I left I've put under the MIT license, which I find pretty good.

I'm trying to keep a clear firewall between that code, even going so far as to keep the namespaces separate.

I hope this helps a little. I know folks are looking to use individual controls in their commercial applications.

While I can't give you a 100% guarantee about the code, I can say I'm pretty sure you have nothing to worry about.

I'm not sure if that sounds more like lawyer speak or marketing speak.

Happy hacking (except where prohibited)

Bag-o-Tricks DatePicker control...uh...

2008-05-07T22:27:00.001Z

90% of the questions I get on the bag-o-tricks fall into one of two buckets.

The first bucket is DatePicker.

While I'd love to take credit (or perhaps blame) for it, I didn't build it.

It was done as a demo by some engineers in a Microsoft office in China.

I have the slightest clue how it is built or how it works (other than I'm pretty sure I'd do a total 180 if I were to try to implement the same functionality.)

I've got a number of bug reports and feature requests. I'm sorry for being quiet on them. DatePicker really doesn't line up with anything I'm playing with at the moment...so I haven't spent much (read "any") time on it.

If anyone has bug fixes or new features, as always, send me me an SVN patch and I'll be happy to get things fixed.

Alternatively, you can always offer to shower me with cash and lavish gifts to dig in on your favorite problem.

I'm not above being bought. :-)

Oh, and it's great being back in Seattle. India was great, but there's no place like home.

India in April

2008-04-01T17:12:00.001Z

This is just a heads-up. I'm going to be pretty quiet for the month of April. I'm getting on a plane in 4 hours for India.

I'm spending the month there--doing a meditation retreat, seeing some sites, hopefully dancing a bit.

If you're a regular reader and live in Mumbai, Delhi, or points in between, let me know. We might be able to meet for coffee.

edeya9902(at)sneakemail(dot)com

Watch my personal blog for updates. If I find a computer, I'll try to make some posts.

Otherwise, see you in May!

>Kevin

IE8, Standards, and Joel is Scary Brilliant

2008-03-17T23:27:00.001Z

By Joel, I mean Joel Spolsky. Not only does he have great taste in presidential candidates, but he's a person everyone in technology should be reading.

It's good to have idols, I think. I dream of having the perspective and wisdom to write like this.

The IE 8 team is in the process of making a decision that lies perfectly, exactly, precisely on the fault line smack in the middle of two different ways of looking at the world. It’s the difference between conservatives and liberals, it’s the difference between "idealists" and "realists", it’s a huge global jihad dividing members of the same family, engineers against computer scientists, and Lexuses vs. olive trees.

Of course he's talking about how IE8 will handle web standards when so much of the world expects IE to work the way it has always worked. Is there a solution? According to Joel:

There is no solution. Each solution is terribly wrong. Eric Bangeman at ars technica writes, "The IE team has to walk a fine line between tight support for W3C standards and making sure sites coded for earlier versions of IE still display correctly." This is incorrect. It’s not a fine line. It's a line of negative width. There is no place to walk. They are damned if they do and damned if they don't.

His Martian headset analogy is just a bit forced, but totally forgiven. The write-up is brilliant and fascinating.

Like Joel, I'm going to sit back with some popcorn.

...it will be really, really entertaining to watch...

Rob Relyea Hates my Mom

2008-03-17T17:37:00.001Z

My mother is a lovely woman. So I'm confused as to why Rob dislikes her so much.

Let me back up. Last August (when I was still at my former employer) I did some demos of new features in WPF 3.5 for Channel 9.

I was happy to see Rob reused some of the same demos for his MIX '08 Talk.

When I was watching the Add-In demo, I was surprise to see the data had remained the same--for the most part. My dad--Robert, my brothers--Brian and John, and I were still in the data set.

But my mother--Wynette--replaced by "Web Service". I mean, I know WCF is powerful, but it's a poor replacement for the most wonderful woman in the world--even if she has an uncommon name.

I did find it funny that the last name was left unchanged.

So come on Relyea. Let's hear it. I think I deserve an explanation. :-)

Reader Question: "Why WrapperElement instead of Decorator?"

2008-03-14T21:16:00.001Z

Yuval, via a comment, asks:

Can you explain why you chose to define WrapperElement<T> instead of simply inheriting from Decorator? They seem to be doing the same thing.

Ah, it is good to read my post "Don't subclass a Panel, unless you're making a Panel".

First, where do I used WrapperElement<T>? Well, at the moment, it's used in three places: FlipTile3D, Set, and Transition3D. In all cases it simply wraps a Viewport3D.

Now, could I simply use Decorator? Sure. I could subclass Decorator and do basically the same thing. Even easier: I could subclass Viewport3D.

Why don't I?

It's all about API usability and correctness.

When I write a control (especially for the bag-o-tricks) I try to make it "right".

If these controls subclassed Viewport3D, they should act like Viewport3D. Meaning, they should support someone added arbitrary lights, models, etc. They should support messing with and removing elements that are already added.

I don't want this.

Wrapping everything with a Decorator, just exchanges problems.

If I subclass Decorator, it would imply that I mean people to treat the control like a Decorator, which means accessing and changing the Child property.

I don't want this, either.

WrapperElement<T> does some very simple things.

Stores a Framework element as a child visual.
Adds it to its visual tree (via AddVisualChild)
overrides GetVisualChildCount
overrides VisualChildCount
overrides MeasureOverride
overrides ArrangeOverride
Provides protected access to the child so the subclass can play with it, but not the end user.

One should use WrapperElement<T> when one wants to use the implementation of an existing component--Viewport3D, Grid, etc.--but doesn't want the object model of that component exposed.

Make sense?

Thanks for the question, Yuval.

Happy hacking.

Consolas: the Coder's Font

2008-03-13T02:36:00.001Z

Consolas is one of a set of new ClearType fonts that shipped as part of Windows Vista and Office 2007.

It's absolutely beautiful. I love to code in it.

The problem: no applications seem to be smart enough to use it by default. In this post, I'll go through all the places I use monospaced fonts

Visual Studio

Tools->Options->Environment->Fonts and Colors

Set "Plain Text" under "Display Items" to Consolas.

Firefox

Tools->Options

Under the Content tab, in the "Fonts & Colors" box, pick "Advanced". In Monospace, pick Consolas.

Internet Explorer

Tools->Internet Options

General tab, under Appearance, pick 'Fonts'.

Under "Plain text font:" pick Consolas.

.NET Reflector

View->Options

Under 'Appearance', 'Code Font': Consolas.

CMD.EXE

(Thanks to Walter for pointing this out to me.)

Yes, even the command window. If you're running Vista, make sure to run this command 'elevated'. You'll have to restart your machine before the setting takes effect.

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Console\TrueTypeFont" /v 00 /d Consolas

Next, right click on the command window header and pick 'Properties'. You'll probably want to up the font size, too.

And there you go. All your most important applications using the nicest monospaced font.

Happy hacking!

Bag-o-Tricks March '08 Edition

2008-03-09T04:30:00.001Z

January 12 was my last update to the bag-o-tricks. I couldn’t let two months go by without another refresh. There is a lot of stuff here I've already talked about. The code has been available via SVN for a while, but not in the convenient package.

The Goods

Binaries and Source [zip, 4.17MB]. Tested with Visual C# Express 2008.

The Details

VS Copy-to-HTML - New!
- Blogged about it here.
NotifyWorker - New!
- Blogged about it here.
HueConverter - New!
- Makes it easy to create a pretty spectrum of colors for a number of items
Animating Tile Panel
- Renamed AnimateNewItem property to AnimatesNewItem
- Made initial load not animate new items
- Polished the demo code
CompositionTargetRenderingListener
- Added Dispose and used it where appropriate
- Added WireParentLoadedUnloaded helper method
DemoCollection
- Added Reset command
- Moved to library assembly
Extentions
- Added SelectResursive (see last blog post), among others
FlipTile3D
- Moved to WrapperElement<Viewport3D>
FolderPicker
- Moved to new SelectRecursive implementation
WPFUtil
- Added HSB-RGB converter
- Created ‘Animate’ methods to abstract physics model. Moved FileTile3D, AnimatingTilePanel, and ZapDecorator to these.
ZapScroller
- A lot cleaner. Removed a completely unnecessary layer of complexity.
- Added the ability to template the buttons. Thanks for the suggestion, Atul.
WPF Set
- New in 3D! See blog post.
General
- A bunch of renaming of namespaces. Most of the new stuff will exist under J832.Wpf

As always, the SVN location has been updated. Patches are always welcome. (I've had one taker on this. Very cool to do an apply patch. Would love to do it again.)

Enjoy and happy hacking!

iPhone makes me a better person

2008-03-07T23:57:00.001Z

...or at least it makes me feel that way.

Let's rewind.

When I moved to Seattle in 2002, I had a simple, "candy bar" Nokia phone. I could barely text message with it, but it worked.

My first Windows Mobile phone was the Audiovox SMT5600--a fancy name for the HTC Typhoon. I could sync calendar and contacts over the air with Exchange. I could T9 through my address book.

I felt like I jumped 18 months into the future. I got the upgraded version of the Typhoon (with the weird bump on the top). It ran a newer version of Windows Mobile. It had a prettier screen. Let's say I jumped forward another 6 months.

Then I went BlackJack. Bigger screen. Keyboard. A reasonable browsing experience, at least for GMail. Maybe a jump of a year into the future.

After a brief stint, I managed to loose my BlackJack, and went to BlackJack 2. Slicker look. Newer version of Windows Mobile. Maybe a 6 month jump.

Fast-forward to Sunday. I was snowboarding with some friends. My phone was in my pocket. My pocket was open. I was in the terrain park. I lot my phone.

Damn.

So I go back to the AT&T store. And the iPhone stand starts calling to me.

I have many friends with iPhone.

Both of my brothers have one.

I get one.

It's been less than a week.

Easily a 5 year jump. I feel like I'm living in the future. The thing freakin' rocks. It makes the BlackJack2 look like a joke.

Not only have I ditched Windows Mobile, I've ditched Zune. I've gone to buying MP3s from Amazon's store. Instant gratification. No expiration. No DRM.

This is the future.

It flawlessly syncs with Outlook on my desktop. (I have a friend who's been trying to get it to work with her BlackJack for months.) The experience with iTunes is great. Maps, Email, SMS, all clean and beautiful.

With the announcement of the SDK and Enterprise support (over-the air sync with Exchange, etc) I can't imagine a better setup for a phone.

I'm sure Google will have a cool offer with Android. I'm sure MS is sweating bullets and cranking on some interesting stuff. At least I hope so.

In the end, the bar has been raised--by a lot. All mobile users will benefit in the long-run by the existence of iPhone.

Especially those that have one.

I couldn't imagine going back.

Let me say it again: wow.

Dump Evite

2008-02-21T08:45:00.001Z

Cross-post from my personal blog.

This article from the January Wired got me started:

An email arrives announcing a fete, but it's short on deets. You're forced to click to an ad-choked Web page, then another to RSVP, and then back to the first to see the info again. That faint sound you hear? It's coins tumbling into the pockets of media conglomerate IAC/InterActiveCorp, which acquired the site in 2003.

It's been 2 days since I read the article and I've received 4 evites. It's time to put a stop to this.

The article recommends Socializer as an alternative, but it's way too heavy for my taste. The sign-up experience should be almost invisible.

What I want:

Painless sign-up
Time and location details in the email
+1 if it includes a link to a map
+1 if the map link is to Google Maps
+1 if a calendar file is attached for us Gmail/Outlook users.
Super-clean user experience.

Invitastic nails it. There are no crazy custom themes or anything and I'm fine with that. Kudos to the Jackson Fish Market folks.

Goovite also looks promising. It includes the ability to offer a number of possible meeting times and allow a discussion about when.

Progress rocks!

Xaml Serialization with WCF

2008-02-05T08:06:00.001Z

So I'm reading RESTful Web Services and I got inspired. Sounds like a great way to expose data on the web.

I've heard great things about WCF support for REST, with their new WebGet attribute and such.

So I fire up Visual C# Express and get hacking.

Amazing what one can do in 54 lines of code.

using System;
using System.ServiceModel;
using System.ServiceModel.Web;
 
namespace J832
{
class Program
{
static void Main(string[] args)
{
Time time = new Time();
 
using (WebServiceHost host = new WebServiceHost(time, new Uri("http://localhost:8080/")))
{
host.AddServiceEndpoint(typeof(ITime), new WebHttpBinding(), "time");
host.Open();
 
Console.WriteLine("enter to close...");
Console.ReadLine();
}
}
}
 
[ServiceContract]
public interface ITime
{
[OperationContract, WebGet]
DateTimeCount GetTime();
}
 
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
public class Time : ITime
{
public DateTimeCount GetTime()
{
return new DateTimeCount(DateTime.Now, m_count++);
}
 
private int m_count;
}
 
[Serializable]
public class DateTimeCount
{
public DateTimeCount(DateTime now, int count)
{
Now = now;
Count = count;
}
 
public DateTime Now { get; set; }
public int Count { get; set; }
}
}
 

And we open a browser to http://localhost:8080/time/GetTime:

<DateTimeCount xmlns="http://schemas.datacontract.org/2004/07/J832" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<_x003C_Count_x003E_k__BackingField>0</_x003C_Count_x003E_k__BackingField>
<_x003C_Now_x003E_k__BackingField>2008-02-04T23:28:21.987561-08:00</_x003C_Now_x003E_k__BackingField>
</DateTimeCount>

Isn't that *cough* *choke* pretty *gag*.

I suddenly had a flash of nostalgia...of longing...for Xaml.

Xaml: that wonderful language where document-object mapping is implicit, trivial, and human-understandable.

(I'd love to link to Our 7 Goals of Xaml introduction but the link is dead. Help, Rob?)

Thankfully, XamlWriter is publicly available and WCF is insanely, gratuitously, wonderfully extensible.

WCF services have endpoints.
Endpoints have contracts.
Contracts have operations.
Operations have behaviors.
Behaviors have formatters.
Formatters can have custom messages--for instance, XamlMessage.

Thanks to Maheshwar Jayaraman for the post (and sample) on his old blog that got me started.

The code is a bit longer, but it's mostly boiler plate:

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Web;
using System.Windows.Markup;
using System.Xml;
 
[assembly: XmlnsDefinition("http://schemas.j832.com/demo/2008", "J832")]
 
namespace J832
{
class Program
{
static void Main(string[] args)
{
Time time = new Time();
 
using (WebServiceHost host = new WebServiceHost(time, new Uri("http://localhost:8080/")))
{
ServiceEndpoint endPoint = host.AddServiceEndpoint(typeof(ITime), new WebHttpBinding(), "time");
foreach (OperationDescription operationDescription in endPoint.Contract.Operations)
{
operationDescription.Behaviors.Add(new MyOperationBehavior());
}
 
host.Open();
 
Console.WriteLine("enter to close...");
Console.ReadLine(); 
}
}
}
 
[ServiceContract]
public interface ITime
{
[OperationContract, WebGet]
DateTimeCount GetTime();
}
 
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
public class Time : ITime
{
public DateTimeCount GetTime()
{
return new DateTimeCount(DateTime.Now, m_count++);
}
 
private int m_count;
}
 
[Serializable]
public class DateTimeCount
{
public DateTimeCount(DateTime now, int count)
{
Now = now;
Count = count;
}
 
public DateTime Now { get; set; }
public int Count { get; set; }
}
 
public class MyOperationBehavior : IOperationBehavior
{
public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters) { }
 
public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation) { }
 
public void ApplyDispatchBehavior(
OperationDescription operationDescription,
DispatchOperation dispatchOperation)
{
dispatchOperation.Formatter = new MyMessageFormatter();
}
 
public void Validate(OperationDescription operationDescription) { }
}
 
public class MyMessageFormatter : IDispatchMessageFormatter
{
public void DeserializeRequest(Message message, object[] parameters) { }
 
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
{
return new XamlMessage(result);
}
}
 
public class XamlMessage : Message
{
public XamlMessage(object value){ Value = value; }
 
public override MessageHeaders Headers
{
get { return new MessageHeaders(MessageVersion.None); }
}
 
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
XamlWriter.Save(Value, writer);
}
 
public override MessageProperties Properties{ get{ return new MessageProperties(); } } 
 
public override MessageVersion Version{ get{ return MessageVersion.None; }}
 
public object Value { get; private set; }
}
}

And (drumroll) the output from http://localhost:8080/time/GetTime:

<DateTimeCount Now="2008-02-04T23:53:18.884273-08:00" Count="14" xmlns="http://schemas.j832.com/demo/2008"/>

Isn't that pretty? The XmlnsDefinition assembly attribute is the icing that gives you the pretty xmlns.

Do other folks love Xaml? Do you wish it was available outside PresentationFramework.dll?

Let me know. I'm thinking of starting a campaign.

Hear that, Rob? :-)

WPF Set: Now in 3D!

2008-01-31T05:50:00.001Z

I last discussed Set about 3 weeks ago. At the time, my implementation was based on buttons. It worked fine, but when I saw how it looked on a friend's machine running the 'classic' theme I was appalled.

I got thinking: there has to be a way to make this game more interesting.

The answer: 3D and gratuitous animation.

The address for the XBAP hasn't changed: http://j832.com/workBlogFiles/WpfSet/

The source code has been checked-in to my SVN repository. The code files actually live under J832.Wpf.BagOTricksApp, but you can build and play with the stand-alone app by loading the J832.WpfSet solution file. (Thank you, CSProj file linking feature.)

Cool stuff:

The listbox on the right that displays the matched sets now uses AnimatingTilePanel.
First use of the new WPFUtil class, which exposes a set of Animate methods. These basically formalize and abstract my simple attraction-based physics model. I support 1-dimensional (double), 2-dimensional (Point/Vector), and 3-dimensional (Point3D/Vector3D) animation. Check out ZapScroller and AnimatingTilePanel in the source to see the other places these are used.
I've also added some helper extension methods to WPFUtil. Very useful.
Implemented a couple of super-simple 3D components: ButtonBase3D and ToggleButton3D. An interesting exercise. Hoping to move FlipTile3D to these in the future.

Not cool stuff:

Keyboard accessibility has evaporated. With the previous implementation, you could tab around to the buttons and press spacebar to select/unselect a "card". More work than I signed up for in this iteration, but something to keep in mind.
WPF handles z-order great in 3D unless you have transparency in your textures. Take a look at the corners of raised cards. Very frustrating. The only work-around is to manually re-order the child elements. Lame.
Perf is great...on my super fast workstation. Even on my relatively beefy laptop, I notice some glitching when things are moving around. Ideally, I'd detect machines hardware limitations and degrade the animations. I should probably offer a "turn off the fancy stuff" check box. Eh, V3.

This will of course be included in the next drop of the full bag-o-tricks, but I thought it was cool enough to share out-of-band.

Have fun.

Improving NotifyWorker (and why blogging makes me smarter)

2008-01-27T22:58:00.001Z

My current day job consists of writing middleware and web-based LOB software for an actuarial services company.

David is my primary collaborator and a fellow blogger. We get along amazingly well, but every once in a while, we disagree. The amazing thing, though, is how we handle disagreements.

I'm at a point where I look forward to disagreement! For a reason that I hope more people can come to realize.

If we disagree about how something should work, it's almost always an opportunity for improvement. Specifically, at least one of the following is likely to happen:

I get smarter
He gets smarter
The code gets better

Quite often, it's all three. I know this sounds like motivational speaker talk or corporate training fodder, but it's true. The fact that we often discuss our disagreements with explicit reference to masters is also helpful.

I blog for similar reasons. I'm far from a CLR, C# or WPF expert, at least relative to the experts I've had the opportunity to work with.

I'm just a geek trying to figure things out and sharing as I go. Hopefully what I share is helpful. Often, though, blogging has self-serving benefits. Just taking the time to write down explanations for what I'm doing forces me to rationalize edge cases.

If I had never blogged the recursive flattening craziness, I would have never have seen all of the edge cases I had missed the first time out.

Anyway, to my point.

Simon was kind enough to point out a deadlock in my NotifyWorker code.

FYI: At this point, looking at the code will be quite helpful.

I was doing a Thread.Join() in the middle of a lock. Of course, if the thread in question is waiting on the lock which is held, the thread will never exit. The result: the Join() call will never return.

Deadlock, indeed.

Props to Simon for pointing out this problem.

I moved the Join() outside of the lock and thought I'd fixed the problem.

Maybe, but I also realized another problem.

Dispose is likely called from the UI thread.
Dispose calls Join on my worker thread as discussed above.
The worker thread does Dispatcher.Invoke twice.

What happens if Dispose is called between my check for m_disposed and when the Invoke actually gets to the UI thread?

Dispose will be tying up the UI thread waiting for Join() to return. The worker thread will never terminate because it's waiting for Invoke to get to the UI thread.

Deadlock again.

Darn.

The solution: Move from Dispatcher.Invoke to Dispatcher.BeginInvoke.

BeginInvoke returns an instance of DispatcherOperation. This class has an Abort method which can be used to abort a pending BeginInvoke.

I now have an instance field containing the pending operation, if one exists, which can be aborted via Dispose before the call to Join. I also now enforce that Dispose must be called on the UI thread (by adding a call to VerifyAccess). This ensures that Abort is not called while the worker is synchronized to the UI thread.

After some careful uses of DisaptcherOperation.Wait and some paranoid null checks, I think I'm okay.

As an aside, I also noticed that Dispose() will throw in the case where NotifyNewWork() has never been called. I fixed that, too.

*Sigh*

Threading code is tough. I had to stand up and pace around a few times as I mentally worked through possible edge cases.

As I've said before, I think this implementation is better, but it would be a stretch for me to claim it's correct. Hopefully, it's more correct.

Please keep the questions, comments, and feedback coming (after you take a look at the post about contacting me).

The code will get better and we'll all get smarter.

Happy hacking.

Oleg, what's your email? (Contacting me via my blog.)

2008-01-26T19:48:00.001Z

This has happened a few times, so I thought it would be worth mentioning.

I love comments. I try to blog more than "check out this link" posts. It takes a bit of work. Knowing folks are reading is great. But...
If you're saying more than "interesting post"--if you have comments or questions--please make sure I have a way to contact you.

Oleg Mihailik made an interesting comment about my NotifyWorker post:

As long as you are already using the delegates, you can use closures (local variables) instead of creating artifical types to hold them.

Then you'd have to provide 2 parameterless delegates: one for work item and another for 'OnCompleted' logic on GUI thread.

That simplifies out the packaged parameters' class, AND eliminates the exception catching work by design.

If they care enough to handle exceptions, they'd do it in conventional and readable way: by enclosing the dangerous part in try/catch. And then, they can reflects it in exactly the same 'OnCompleted' delegate.

I have questions for him and I have no clue how to drop him a line.

If you'd like to chat (or talk job offers) please send me an email.

My obfuscated address--edeya9902(at)sneakemail(dot)com--in the left pane, is meant as a test. If you can't figure it out or don't want to go through the effort of doing the manual copy-paste-replace, we probably shouldn't chat.

Or if you post a comment, just make sure you link back to a blog with a contact page. That's more than sufficient.

Thanks.

Responsive UI with Unresponsive Data: NotifyWorker

2008-01-22T22:47:00.001Z

Yes, I finally got off my SelectRecursive kick. This is penance.

The 3-box Visio Diagram

How many user interfaces do you design that follow this pattern?

Okay, almost all of them.

A frequent refrain from users (well, at least me):

Regardless of what you're doing behind-the-scenes, the interface should never hang, stutter, or lag. Ever.

Easily said, right?

Well, while hacking on one of my side projects, I ran into this problem.

I put on my "framework guy" hat and asked, "Can I formalize this into a pattern?"

My answer: NotifyWorker.

Now before I get into NotifyWorker, I should mention BackgroundWorker: a frequently used and well thought-out component supplied by our friends in the Baseclass Library (BCL) for this kind of thing.

The trick performed by BackgroundWorker is simple, but important: allow start/stop/cancel of a task on another thread. It also keeps developers sane who have to deal with strict rules about what can only be done on the UI thread.

The type of tasks for which NotifyWorker was designed fit into a special niche that I think BackgroundWorkre misses:

Tasks that are long enough to lag the interface (0.1+ seconds) but are too short to require tracking of percent complete (so shorter than, say, 5 seconds).
Tasks that are repeated constantly as the UI updates. Think of recalculating a math/physics model or checking a server-hosted word list for a type-a-head find control.
Tasks where the work to be done is--in relative terms--longer than the work to update the user interface. If the task takes 0.1 seconds, but updating the 1,000 controls in your window takes 2 seconds, you should start by tweaking your architecture before using NotifyWorker.

How does it work?

(Reflector is how I learn all of my new APIs.)

The constructor takes three parameters that outline the diagram above and the workings of NotifyWorker:

Func<bool> prework: this is a delegate that is called on the Dispatcher (UI) thread in a WPF application. Delegate passing is a trick I use a lot, and you should, too. The method does the work to take interesting parameters from the UI (control values, etc.) and puts them in a spot where NotifyWorker can safely play on a non-UI thread. If you decide there is nothing interesting to do, you can return false, telling NotifyWorker "never mind".
Action work: this is where the magic happens. This function is called on a background thread which will leave your UI nice and responsive. Be super careful that 'work' only touches state (fields, etc) that you've safely set aside during prework.
Action postWork: the last box in our diagram. It takes the work done in 'work' and updates the UI accordingly. This method, as well as 'preWork', synchronizes the UI and background threads, so you don't have to worry about locking.

How do you kick things off? Call NotifyNewWork. This method can be called often, if you want. Put it in the 'Changed' handler of your favorite Slider or TextBox. If NotifyWorker is idle, it will wake up and immediately call preWork. If NotifyWorker is busy, it'll loop right around to get new input values as soon as postWork is done.

A demo

Sexy, huh?

The scenario is simplistic and contrived, like so many good demos.

Both sets of UI do the same thing: take the values from two sliders and sum them. Not too complicated.

For some strange reason, the sum 'routine' takes 0.25 seconds to return a result.

Maybe it's that new math...

Eh, it's probably the Thread.Sleep(250) I put in the method.

Anyway, use your imagination. You'll notice that the 'slow' UI is, well, slower. It lags a bunch as you drag the sliders since it's calling the expensive sum method on the UI thread.

The NotifyWorker controls do much better because the expensive call is hidden off-thread.

Simple, but useful.

Odds and ends

You'll notice a LastClientExceptionEventArgs property and a ClientException event. These are designed to make it a bit easier to handle non-critical exceptions during 'work'. The demo code actually shows this off pretty well.

You'll also notice that NotifyWorker implements IDisposable. Dispose will make sure to end any background work when you're done with NotifyWorker.

Under the covers, NotifyWorker uses LockHelper and some of the pulse/monitor tricks I wrote about a few months ago.

That's about it.

Since NotifyWorker is hard-wired to the notion the Dispatcher, it lives in J832.Wpf.BackOTricksLib. The demo is in the Bag-o-Tricks app under NotifyWorker.

I'm not going to do an official release (zip with binaries/source) of the bag for this sample. It's cool, but not cool enough to warrant a whole new drop.

It also gives you an excuse to play with SVN, if you haven't already. You can always just manually download the code from my SVN share using your browser, too.

Let me know if this works well for you.

Happy multi-threaded hacking!

Note: I've had some funky auth issues with Firefox on the SVN server lately. Let me know if you have any trouble.

SelectRecursive: If 3rd times the charm, 4th times a warning

2008-01-20T02:49:00.001Z

I thought I finally nailed SelectRecursive--my Linq-friendly extension method for navigating homogenous hierarchies. In my infinite cleverness, I figured I could avoid paying the common call stack cost of recursive algorithms by creating my own stack.

The solution I posted Wednesday was an okay start of the philosophy, but I really messed up the implementation.

I thought I got it right yesterday, but after being bitten once, I was cautious--notice I said "Smart(er)".

Well, the implementation yesterday was certainly better, but it was missing a critical component: correct clean-up.

IEnumerator<T> implements IDisposable.

Why? Well, suppose you're enumerating over a database table. When one is done walking through the items, you might want to close your connection.

We rarely see the use of IDisposable in this context, because it's hidden behind the 99.999% use of IEnumerable<T>--foreach.

Don't forget that this:

foreach (object item in sourceEnum) 
{ 
    // do something 
}

Looks like this to the runtime:

using (IEnumerator<object> source = sourceEnum.GetEnumerator()) 
{ 
    while (source.MoveNext()) 
    { 
        // do something 
    } 
} 

Well, actually it looks like this:

IEnumerator<object> source = sourceEnum.GetEnumerator(); 
try 
{ 
    while (source.MoveNext()) 
    { 
        // do something 
    } 
} 
finally 
{ 
    source.Dispose(); 
} 

foreach does the work of calling Dispose() on the enumerator--both when things go well and if there is an exception thrown in the while loop.

Since the "simple" version of SelectEnumerator I posted yesterday uses foreach, everything works great. Even if an exception is thrown deep in the recursion, the unrolling of the stack will go through all of the nested finally blocks.

The "smart(er)" version of SelectEnumerator will have to be smart to handle disposing every enumerator it creates--both when the stack is popped normally and in the case of an exception.

public static IEnumerable<TSource> SelectRecursive<TSource>( 
    this IEnumerable<TSource> source, 
    Func<TSource, IEnumerable<TSource>> recursiveSelector) 
{ 
    Stack<IEnumerator<TSource>> stack = new Stack<IEnumerator<TSource>>(); 
    stack.Push(source.GetEnumerator()); 
 
    try 
    { 
        while (stack.Count > 0) 
        { 
            if (stack.Peek().MoveNext()) 
            { 
                TSource current = stack.Peek().Current; 
 
                yield return current; 
 
                stack.Push(recursiveSelector(current).GetEnumerator()); 
            } 
            else 
            { 
                stack.Pop().Dispose(); 
            } 
        } 
    } 
    finally 
    { 
        while (stack.Count > 0) 
        { 
            stack.Pop().Dispose(); 
        } 
    } 
} 

Take a look at the code from yesterday to see the diff.

At this point, I'm pretty nervous about saying I've gotten this "right". In all honesty, I did the stack flattening to see if I could do it and do it well.

As I've mentioned before, this pattern is only useful if you plan on having prohibitively deep hierarchies where the cost of the churning the runtime stack or the chance of stack overflow is high.

If neither is the case, keep things simple.

Remember what I said about clever.

Happy hacking.

Source code, HTML, and an Exercise for the Reader

2008-01-19T03:57:00.001Z

No clue why I want to be vague about this. Probably because I'm late for a party, but really wanted to share.

And you're smart. You'll figure it out.

 <Window x:Class="MainWindow"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     Title="VS Copy-Paste to HTML" >
     <Grid>
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="*" />
             <ColumnDefinition Width="*" />
         </Grid.ColumnDefinitions>
         <RichTextBox Name="m_richTextBox" TextChanged="m_richTextBox_TextChanged" />
         <TextBox Grid.Column="1" Name="m_textBoxHTML" />
     </Grid>
 </Window>
 
 

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Web;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Documents;
 using System.Windows.Media;
 
 public partial class MainWindow : Window
 {
     public MainWindow()
     {
         InitializeComponent();
     }
 
     private void m_richTextBox_TextChanged(object sender, TextChangedEventArgs e)
     {
         m_textBoxHTML.Clear();
         m_textBoxHTML.AppendText("<div style=\"font-family:monospace;\">" + Environment.NewLine);
         foreach (Paragraph paragraph in m_richTextBox.Document.Blocks.Cast<Paragraph>())
         {
             foreach (Run run in Decompose(paragraph.Inlines))
             {
                 m_textBoxHTML.AppendText(toCleanedColoredSpan(run));
             }
             m_textBoxHTML.AppendText("<br/>" + Environment.NewLine);
         }
         m_textBoxHTML.AppendText("</div>");
     }
 
     private string toCleanedColoredSpan(Run run)
     {
         SolidColorBrush solidColorBrush = run.Foreground as SolidColorBrush;
         if (solidColorBrush == null)
         {
             return cleanString(run.Text);
         }
         else
         {
             if (solidColorBrush.Color == Colors.Black)
             {
                 return cleanString(run.Text);
             }
             else
             {
                 string colorString = solidColorBrush.Color.ToString();
                 Debug.Assert(colorString.Length == 9);
 
                 colorString = colorString.Substring(3);
 
                 return string.Format("<span style=\"color:#{0};\">{1}</span>",
                     colorString, cleanString(run.Text));
             }
         }
     }
 
     private string cleanString(string source)
     {
         source = HttpUtility.HtmlEncode(source);
         source = source.Replace(" ", "&nbsp;");
         return source;
     }
 
     private static IEnumerable<Run> Decompose(IEnumerable<Inline> inlines)
     {
         foreach (Inline inline in inlines)
         {
             if (inline is Span)
             {
                 foreach (Run run in Decompose(((Span)inline).Inlines))
                 {
                     yield return run;
                 }
             }
             else if (inline is Run)
             {
                 yield return (Run)inline;
             }
             else
             {
                 throw new NotSupportedException();
             }
         }
     }
 }
 

Recursion, Linq, etc. - 3rd Times the Charm

2008-01-18T16:12:00.001Z

The joke about Microsoft is that it always takes them three times to get it right.

If you look at my posts on the game Set in WPF, it would seem I follow the same pattern.

Well, here I go again.

Let's start simple: I have a path to a directory and I want to enumerate over all of it's subdirectories recursively. To be super concrete:

string[] startPaths = new string[] { @"D:\j832_svn\PublicSoftware\" };  
IEnumerable<string> subPaths = SelectRecursivePaths(startPaths);

Easy enough.

What's the scenario-specific implementation of SelectRecursive? Well, our friend System.IO.Directory provides what we need.

private static IEnumerable<string> SelectRecursivePaths(IEnumerable<string> paths) 
{ 
    foreach (string path in paths) 
    { 
        yield return path; 
        foreach (string subPath in SelectRecursivePaths(Directory.GetDirectories(path))) 
        { 
            yield return subPath; 
        } 
    } 
} 

This code does the job for doing an in-order, recursive traversal of all of all of the directories. But it isn't very Linq-ish, is it?

Getting Linq-ish: SelectRecursiveSimple

Could there be a way to extract out the call to Directory.GetDirectories such that this method could be used over any homogenous, hierarchical structure? Yup.

public static IEnumerable<TSource> SelectRecursiveSimple<TSource>( 
    this IEnumerable<TSource> source, 
    Func<TSource, IEnumerable<TSource>> recursiveSelector) 
{ 
    foreach (TSource element in source) 
    { 
        yield return element; 
        foreach (TSource subElement in recursiveSelector(element).SelectRecursiveSimple(recursiveSelector)) 
        { 
            yield return subElement; 
        } 
    } 
}

Now we change the call site to embody the call to GetDirectories:

IEnumerable<string> subPaths = startPaths.SelectRecursiveSimple(path => Directory.GetDirectories(path));

I love lambda expressions and extension methods.

With me so far?

Getting Clever: SelectRecursiveClever

Now we go back to my clever idea from Tuesday and Wednesday about flattening recursion. The code I ended up with:

public static IEnumerable<TSource> SelectRecursiveClever<TSource>( 
    this IEnumerable<TSource> source, 
    Func<TSource, IEnumerable<TSource>> recursiveSelector) 
{ 
    Stack<TSource> stack = new Stack<TSource>(); 
    source.Reverse().ForEach(stack.Push); 
    while (stack.Count > 0) 
    { 
        TSource current = stack.Pop(); 
        yield return current; 
        recursiveSelector(current).Reverse().ForEach(stack.Push); 
    } 
}

Note: ForEach is an extension method I created that does what Array.ForEach does: calls an Action<T> delegate on each item. In this case, pushing every item in the sequence into the stack.

Now the caller-side behavior of this is exactly the same as the "simple" version above. The implementation tries to be "clever" though, by discarding the "naive" use of recursion by replacing the call stack with a local stack. I was quite proud of this implementation. As I said on Tuesday:

If you can flatten a recursive implementation, you will have a better understanding of what's really going on under the covers.

Gulp. Perhaps I spoke to soon.

The Problem with Clever

I showed a co-worker this code. It took a bit of work to explain the use of .Reverse(). Stacks are Last-in-first-out, so if you want to get the first item out first, you have to put it in last.

Explaining this hurt my head a bit. In the "simple"--read "naive"--implementation, one didn't have to reverse the enumeration. Why should the flattened version be different?

The answer: it shouldn't.

At some point in the "clever" implementation, every item is on the stack. This means if you have a very wide tree, the stack could grow to be huge.

Imagine your recursiveSelector is smart about not loading all items at a given level into memory at one time--the benefit of sequences, right? It doesn't matter, because SelectRecursiveClever will load everything in one level into a stack. It trades the potential benefit of a smaller call stack with the potential blow-up of your working set when iterate over a folder with 10,000 sub-folders.

Oops.

You have to keep track of your depth in the recursion somewhere: either the runtime stack or your own stack.

But all you have to keep track of is where you are in each sequence at each level. You don't have to queue up all of the items at a given level.

Turns out the CLR has this obscure feature to handle this: IEnumerator<T>.

Yeah, not so obscure.

It's actually what the simple version of this code does. When you call down into the nested SelectRecursiveSimle, an IEnumerator<T> will be waiting patiently at the the current spot for the call to return.

Getting Smart(er): SelectRecursive

The code is more ugly, but it also does a better job of illuminating what is happening in the truly recursive, "simple" version.

public static IEnumerable<TSource> SelectRecursive<TSource>( 
    this IEnumerable<TSource> source, 
    Func<TSource, IEnumerable<TSource>> recursiveSelector) 
{ 
    Stack<IEnumerator<TSource>> stack = new Stack<IEnumerator<TSource>>(); 
    stack.Push(source.GetEnumerator()); 
 
    while (stack.Count > 0) 
    { 
        if (stack.Peek().MoveNext()) 
        { 
            TSource current = stack.Peek().Current; 
            yield return current; 
            stack.Push(recursiveSelector(current).GetEnumerator()); 
        } 
        else 
        { 
            stack.Pop(); 
        } 
    } 
}

2008-01-19: Turns out this code is wrong, too.

The stack now holds on to what it should: the IEnumerator<T> at each level. The while loop runs through IEnumerator<T>.MoveNext(), going deeper with every stack.Push() until there are no more items and then "returning" with stack.Pop().

Popping the stack

It's pretty easy to implement a recursive construct using Linq. The first "simple" implementation works great and it's really useful when partying over the file system or any other hierarchy.

I still claim that flattening recursive code is a good thing to do for reasons I mentioned on Tuesday.

Just make sure you do it correctly.

Put another way: pay attention to your masters.

If you can't be smart, be simple.

Don't ever be clever.

Clever will burn you.

Happy hacking.

PS: SVN has been updated again with the latest code. Hopefully the last time I'll touch RecursiveSelect for a while.

Remembering why I like single-vendor platforms

2008-01-18T08:44:00.001Z

Now before I start a flame war, remember what I wrote in September:

I believe in open standards. The only way to protect and encourage open standards is to have many prevalent implementations of said standards.

Having said that, there are still a lot of reasons to love single-vendor, even closed, platforms.

One of those reasons: compatibility.

I had a simple goal: change my blog theme from fixed-width to fluid-width.

Code lines tend to take up a lot more space than 450px. Formatting C# for narrow columns is a pain.

I searched and hacked in vane for over an hour before I found a CSS solution.

The whole time there was a 16-year-old inside of me yelling: "Just use tables! They worked great in 1996!"

I'm going to spare you the gnarly details, but it involves negative margins. (Yes, negative margins. I almost fell off my Swiss ball.) Huge props to the folks at Dynamic Drive for their straight-forward-as-can-be-expected walk-through of fluid, two-column layouts in CSS.

After a bunch of tweaking, I got everything looking good in Firefox. I then jumped into Live Writer to start writing. I updated the cached theme for my blog. It looked really broken. Why?

Well, Live Writer uses Trident--the IE rendering engine.

After much hacking, I discovered that IE cares about the order of <div> elements in situations where Firefox doesn't. Also, Firefox respects // to mark comments in CSS. IE doesn't.

After another hour, I got things working in both.

No I haven't tested in IE6 or Safari. Please let me know if you have issues.

I'm guessing I'm one of the few who look at my blog in a browser--most probably use a blog reader.

Good idea.

Flattening recursive algorithms with Linq

2008-01-16T21:13:00.001Z

I wake up this morning to find a comment from Stefan regarding my post yesterday about flattening recursion:

In the future version of C# we may receive a new language construct yield foreach which will eliminate this problem. Read this paper by Erik Meijer or this blog post by Wes Dyer if you are interested.

Ironically, I had read the paper and associated blog post last week.

And it got me thinking: could I abstract out my recursive traversal?

Even better: could I abstract it out in a way that was Linq-friendly?

The answer to both: oh yeah.

Check out the browser-friendly source here.

Now the code to find all of the selected directories becomes

SubDirectories
.SelectRecursive(directory => directory.SubDirectories)
.Where(directory => directory.IsSelected);

How's that for straight-forward?

Note 1: The savvy reader will notice that the third implementation is now like the original: the target node is not included in SelectedDirectories if it is selected. I like this more.

Note 2: Since I made SelectRecursive more general, I'm not quite as efficient about creating a bunch of enumerable instances. I still (likely) save a lot in call stack space and having a general implementation is pretty cool.

Note 3: You'll notice that SelectRecursive handles the case where there recursiveSelector returns null. This is different than how default extensions like SelectMany work. It made my usage in this scenario cleaner, but it's important to note. Or not. This bothered me for reasons I'll go into in another post. The code as checked-in now throws if null is returned. These subtle implementation details can cause headaches later.

As I mentioned yesterday, you can get the full source code from my SVN repository. The new methods extension methods have been added to Extensions.cs in J832.Common.

Happy recursive Linq-ing!

Flattening recursive algorithms is like taking the stairs...

2008-01-16T04:05:00.001Z

...it's rarely necessary, but you'll be better for it.

Okay, a forced analogy.

2008-01-19: I've learned a lot since Tuesday. Please read!

I'm sure many remember their first algorithms class and their first introduction to recursion: the infamous Tower of Hanoi problem. I'd been coding for a while when I was presented with this puzzle and wondered (probably out loud), "Why don't we use a more concrete example, like the file system?"

I guess I've always been more of a software engineer than a computer scientist.

While the idea of recursion is useful in many situations, the costs are rarely discussed. As our friends at Wikipedia mention:

...in today's programming languages, the stack space available to a thread is often much less than the space available in the heap, and recursive algorithms tend to require more stack space than iterative algorithms.

Well said.

I was hacking on some work stuff that required recursion-- specifically flattening a hierarchy. I realized I'd done this before, in the bag-o-tricks. I also realized how expensive it was.

Not only was I paying in call stack space for every nested call, but I was also allocating a lot of enumerators.

Code for the SelectedDirectories getter.

if (m_directories != null) 
{ 
    foreach (SelectableDirectory sd in m_directories) 
    { 
        if (sd.IsSelected) 
        { 
            yield return sd; 
        } 
        foreach (SelectableDirectory sd2 in sd.SelectedDirectories) 
        { 
            yield return sd2; 
        } 
    } 
} 

So how does one improve this? Replace the call stack with your own stack.

Stack<SelectableDirectory> directoryStack = new Stack<SelectableDirectory>(); 
directoryStack.Push(this); 
while (directoryStack.Count > 0) 
{ 
    SelectableDirectory currentDir = directoryStack.Pop(); 
    if (currentDir.m_directories != null) 
    { 
        for (int i = (currentDir.m_directories.Count - 1); i >= 0; i--) 
        { 
            directoryStack.Push(currentDir.m_directories[i]); 
        } 
    } 
    if (currentDir.IsSelected) 
    { 
        yield return currentDir; 
    } 
}

The savvy reader will notice that the second implementation is slightly different: the target node is included if it is selected. Just a detail.

So, what has improved? Only one enumerator is created. The call stack space for the recursion is also eliminated. The cost is the creation of the local Stack<> to keep track of the location in the hierarchy, which is likely much smaller than the space required for a call stack frame.

Since we want to keep the original order of items returned, we also have to Push each level of directories into the Stack in reverse order, so that the Stack returns them in the original order.

Now how does this match up with our masters?

It's certainly less readable. Since the code's not documented, it would probably take longer for even a savvy dev to figure out what's going on. This means it's less maintainable--certainly a negative.

On the plus size, the scalability of this algorithm is now limited by the size of the heap, which is much larger than the call stack. This only matters if one plans to parse very deep directory structures, though.

Another plus is likely performance, since fewer objects are instantiated and the cost of manipulating a local Stack<> is likely much cheaper than churning the call stack. I say 'likely' because I'm not really sure. I should absolutely measure the performance to be certain. Even then, the perf gain is likely trivial unless this code is called a lot. In that case, it might make sense to cache the result of the method.

In the end (and as always), context really matters. I think this is a good exercise to understand the costs and to challenge one's understanding of recursion. If you can flatten a recursive implementation, you will have a better understanding of what's really going on under the covers--something that is always useful.

Happy hacking!

Note: the updated code for Folder Picker has been committed to the bag-o-tricks directory in my SVN repository. You can take a look at the old implementation using Tortoise. Right-click on Data.cs in the shell. Pick 'Show log' out of the Tortoise menu. Then right-click on revision 58 and pick 'Update item to revision'.

A REAL update to the Bag-o-Tricks

2008-01-13T02:30:00.001Z

The last update to the bag-o-tricks was pretty lame, I'll admit.

As I discussed a bit ago, a lot of people code to "get it done yesterday". It's clear, looking through a bunch of the code, that I had this mentality about a lot of the samples. Moreover, it's clear that the masters of code quality, maintainability, and best-practices were often ignored.

Here's an attempt to put my money where my mouth is.

The Goods

Binaries and Source [zip, 4.3MB]. Developed with Visual C# Express 2008.

The Details

Set - New!
- The XBap I posted last week is now part of the bag-o-tricks.
- Did some clever project linking to allow building XBap without duplicating files.
Interactive 3D - New!
- Added the 3D demos I discussed a while ago
- A lot of clean-up to make the code more suitable for general use
AnimatingTilePanel
- Ability to animate in newly added items
- Made dampening make sense: bigger number = more dampening
- Add Variation property to make item movement make more organic, if desired
- Added validation to the public properties
- Moved frame tick register/de-register to new CompositionTargetRenderingListener
- Perf: Stopped ‘ticking’ when nothing is changing
- Stopped using clock time between ticks to affect animation: complexity with little benefit
- Made ItemHeight/Width attached properties that can be added to a host ItemsControl.
- Demo: moved to DemoCollection -> now you can see how changes to the source collection are reflected
Graph
- Removed a completely silly use a Dictionary. Clever perf optimization that made the code bloated, confusing, and probably slower.
- Renamed CoefficientOfDampening -> Dampening
- Rename FrameRate -> Attraction
- Removed unneeded HideAnimationManager -> thank you anonymous methods.
- Demo: A bunch of clean-up in the Node data files. Should never have used DispaterObject.
- Demo: Moved to dispatcher timer for churning the graph nodes: a lot cleaner and more efficient than a separate Thread.
Zap
- Removed shameful implementation of IPropertyChanged on top of a DependencyObject
- Eliminated gratuitous subclassing of DependencyObject by ZapCommandItem
- Removed FirstPreviousNextLastCommand (and associated enum) -> thank you ActionICommand
- Fixed some pretty glaring bugs in not-so-edge cases
- Demo: moved to DemoCollection
ActionICommand - New!
- Commands often expose the functionality of existing methods. So why can’t exposing a command be as simple as wrapping the existing method? Exactly.
WrapperElement - New!
- A while ago, I discussed not subclassing Panel unless you’re making a Panel. Well, sometimes all you want to do is compose a single element without exposing it's state to the world. WrapperElement makes the process of wrapping a child element trivial.
CompositionTargetRenderingListener - New!
- A class that can be used to manage listening to the static CompositionTarget.Rendering event. I use this pattern so much, it made sense to make a separate class.
Demo: DemoCollection - New!
- Writing controls that handle INotifyCollectionChange can be tough. Wouldn’t it be nice to have a class that makes testing (and then showing off) your list-bound control easy? I thought so.
General
- Removed a lot of unused parameters and privates. Thanks, FxCop.
- Demo: Moved the introduction page to FlowDocument. Why I didn’t do this a year ago, I’ll never know.

As always, the SVN location has been updated. Patches are always welcome (No one has taken me up on this yet. Would love to try it out.)

Enjoy and happy hacking!

WPF 3.5 Demo Posted: Add-ins and Interactive 3D

2008-01-09T04:10:00.001Z

Way back in August, I posted about my last Channel 9 interview where I discussed new stuff in WPF for 3.5. At the time, I was a slacker about getting the code for the demos out.

Well Karsten has picked up my slack.

I only have C# 2008 Express installed and for some reason it doesn't like how complicated I made the solution, so I can't claim to have built/run the code as Karsten has posted it. I'm sure it's fine, though.

WPF Set - This is a good stopping spot

2008-01-08T08:55:00.001Z

The graphics pretty much match the actual game now.
Moved the New Game button to minimize accidental clicking.
Some small tweaks to the game logic.

URLs are the same as before:

XBAP
Source and Binaries [Zip, 54KB]

Bleh! The third night this darn game has kept me up past midnight. I need another hobby.

The Game "Set" in WPF (Redux)

2008-01-07T05:41:00.001Z

Yesterday (well, early this morning) I posted my first stab at the game Set implemented in WPF.

Amazing what 20 hours of bake time can do.

Removed insanely complex and unnecessary optimization that made the code for SetGame.TryPlay almost un-readable.
Cleaned up the 'test' mode by removing it. If you build/run DEBUG, you'll get a Test button. If you build/run RELEASE, you won't.
Used binding in the WPF app where it makes sense.
Added a bunch of caching to the card generation on the WPF side. Re-creating a bunch of brushes and pens is silly.
Added a test project: WpfSet_Test to run the data model through its paces.
Fixed deployment to actually use Visual Studio Deploy functionality. (Yesterday, I just uploaded the files from the build directory.) If you accessed the XBAP yesterday, please refresh and make sure the title says at least "WPF Set - 2008-01-06" and not "WPF Set - 2008-01-05." If refreshing doesn't move you beyond 2008-01-05, there is something fishy with your application cache. Drop me a line and I'll try to fix it.

The XBAP URL hasn't changed.

I've combined the source and binaries into one zip file [53KB]. I've always thought having dated copies of files was goodness, but then I realized if someone links to the old version, they'll never get updates. I'm going to try to keep an updated read-me in the zip file so folks know what version they've downloaded.

As always, send me an email or a comment if you have questions.

Happy Setting.

The Game "Set" in WPF

2008-01-06T09:10:00.001Z

Update - 2008-01-06: See this post for new details. Links below have been changed.

In theory, I have so many more important projects to work on. This was one of those ideas that got legs faster than I realized I should be working on something else.

If you haven't heard of Set, check it out company site or the Wikipedia entry.

Building the data model was half the fun. This is some of my first code that uses Linq features from .NET 3.5. I'm blown away. Without a doubt as big as generics. Wow!

The UI is super minimal and that was the goal. Get it all working and ponder prettier/sexier things later.

So, if you want to play:

XBAP - Requires Microsoft .NET Framework 3.5. (Works in IE and Firefox.)
Source and Binaries [53KB zip]

As I've discussed before, you can also take a look at the source on my SVN share using you favorite SVN client.

Future ideas:

Add a timer and a notion of players. I think I'd layer this on top of the existing game model to keep things simple and clean.
It would be cool to layer a 3D UI on top of the game model, too. I have some crazy ideas based on the Flip3D stuff from the bag-o-tricks.

Hope you enjoy it!

Note 1: Thanks to Karen for the details on making an XBAP project.

~~Note 2: I'll give a cookie to anyone who sends me an SVN patch that fixes the shapes so they match what's really in the game. (Drop me an email via the link on the right.)~~ 2008-01-08: No cookie for you.

Other bug fixes are always appreciated.

When you code, do you know your Master(s)?

2007-12-29T18:32:00.001Z

There are a whole set of blog posts floating around my head. Discussions of immutability, pre-condition checking, etc. I realized I needed to cover a meta-topic first: the notion of "masters" while programming.

This is a concept I think everyone has, but for most, it remains fuzzy, undefined and un-discussed--which is fine, if you work by yourself.

As I've dived into the software engineering role in the last few months, I've been required to justify my implementation decisions and opinions with co-workers. Given the seemingly limitless ways in which one could solve a given problem with a file full of curly braces and semi-colons, why did I choose the approach I did? Why do I want to change a bunch of existing code? Why am I asking my colleagues to change how they write software?

When it's a simple matter of "does it work or not" there isn't much of a problem, but as many know, writing solid code goes well beyond getting things to build and run.

So, what drives how you write software? When you are at a cross roads (with a co-worker or even with yourself) about how to approach implementation, what guides your discussion? These are your masters.

Examples:

Minimize code size
Minimize code complexity
Minimize unnecessary code churn
Maximize code readability
Maximize correctness
Maximize robustness
Maximize flexibility
Maximize code maintainability
Maximize CPU performance characteristics
Maximize Memory performance characteristics
Maximize API ease-of-use
Maximize the chance another dev will use an API correctly (see Pit of Success)
Opt for immutable data structures
Opt for thread-safe data structures and APIs
Verify pre-conditions
Follow design guidelines
Get it done yesterday!

And none of these have anything to do with solving the problem at hand. They are, for lack of a better term, taxes. Well, except for get it done yesterday.

Some observations:

1) Many (Most? All?) of the masters conflict with at least one other master. CPU vs Memory performance is a trade off for many algorithms. Performance optimizations often hurt code readability. API ease-of-use often bumps up against immutability and thread safety. Therefor...

2) Context really matters. This is an important point to bring up when discussing with co-workers. In this situation, which master is most important?

3) When making your case in a disagreement, make it in terms of the masters you are prioritizing in a given situation. If someone doesn't understand the importance of--say--immutability, you'd better be able to articulate it.

4) Speaking in terms of masters makes everyone a lot more sane. How often have implementation discussions turned into irrational arguments? Using a master-focused format, I've found disagreements turn into pretty simple cases of a disagreement about the relative importance of two masters. Other times, it's a matter of agreeing on an exception to general rule. "While in general, Master A is more important than Master B, in this situation, we should prioritize B because of X, Y, Z..."

5) "Fake" masters get exposed--vices wearing the mask of a real master. This is amazingly important, too. Lazy often wears the mask of code size or get it done yesterday. Clever often wears the guise of unnecessary flexibility or performance improvements, while increasing code complexity and decreasing code readability. (I'm often guilty of this.)

So...

Next time you are struggling with several valid ways to implement something, make the mental check-list: what masters am I serving with each implementation? What masters are really important in this situation?

Next time you disagree with a co-worker about an implementation, ask yourself: what masters is she arguing for? What masters am I arguing for? What masters really matter? Maybe step back a bit and talk through your respective masters and make sure you both understand before you dig in.

Next time you are trying to get it done yesterday, ask yourself: am I just being lazy? :-)

Happy hacking...

Note 1: Huge props to my co-worker, David Potter. A more brilliant, friendly, and fun colleagues I could not ask for. We've been using this master-focused mind set for weeks now and it makes collaborating a blast.

Note 2: I always get a little nervous posting these long, pseudo-philosophical rants with no source code. As always, if you write a comment saying you read this far (and you don't think I'm crazy) you'll make my day.

Bag-o-Tricks Christmas Edition

2007-12-20T21:19:00.001Z

Here's a token gift from me to you. An update to the bag-o-tricks. No earth-shattering features, but a bunch of clean-up. I've made everything work under VS 2008 and rolled up a bunch of common files under a 'common' assembly.

I've renamed the assemblies so it's easy to keep track of what comes from me--everything starts with J832.

I've also done some tweaking so that, by default, images are picked up from the users image folder on XP. You can still override this with a command line parameter.

As I hinted to with my post about TortoiseSVN, I've also put all of my code up on an SVN share: j832.com/PublicSoftware.

I'll try to make sure that the bits I check-in are at least building, but no promises. If you want to fix any bugs and send me the patch, I'd love to try it out. Promise that it's your own code and that you're willing to license your work under the MIT License. You can find my email address on my blog.

Happy hacking and happy holidays!

TortoiseSVN Rocks!

2007-12-11T05:36:00.001Z

Yes, I'm considering writing a book: "Kevin Explores Things That Rock".

My company uses Perforce for source control. It works pretty well (although there is no shell integration and the Visual Studio integration is a bit flaky.)

I have my own projects on the side that I'd like to managed with source control. These are both code projects and non-code (poetry, screen plays, other writing) projects. Like I said, anything that I want backed-up, synced and versioned.

If you're like me, you share a set of conflicting tendencies.

First, a tendency to have many machines that you work on.
Second, a tendency to be paranoid about keeping important data backed-up and protected with good redundancy.
Third, a tendency to hate redundancy! This goes along with SPOT. I hate when things get out of sync. I hate having things spread all over a bunch of machines.

Using a source control system helps a lot with this (especially if you're dealing with text-based data formats).

In the world of OSS, Subversion (SVN) is a big player in source management. It's supported by SourceForge. It's used by a mountain of OSS projects. And (drum roll) it has an amazing Windows shell extension: Tortoise.

Step one: install.
Step two: make directory somewhere on your machine.
Step three: right-click and pick "SVN Checkout..."
Step four: type in the URL of a public SVN repository. There are many out there. Check the list above.
Step five: laugh at how easy it all is.

Tortoise supports the creation of patches. Renaming and branching. It even has great shell indicators so you know what's checked-in and what's pending check-in. (It works great on XP. So-so on Vista.)

Take a look at TortoiseSVN.

If you're looking for hosting for your SVN repository, check out DreamHost.

Happy Hacking...and don't forget to build an test before you check-in. :-)

DreamHost Rocks!

2007-12-09T00:05:00.001Z

I've been all over the map with hosting services. Each has it's own cool features and things that are annoying.

I've finally found one that (almost) has it all: DreamHost.

For $10 a month (paid yearly):

5120 GB per month bandwidth. No, that is not a miss-type. Put another way: 5.120 TB a month. (Now, being realistic, the box it's hosted on would probably melt before you hit that mark. It's almost like offering 50,000 minutes on a cell phone plan when there's only 44,640 minutes in a month. But at least you won't get charged for a Digg hit or something.)
500 GB of storage. Again, not a typo. 0.5 TB.
As many domains as you want. You have to buy the domain names, but you can host 'em all on one account.
As many MySQL databases as you want. Size comes out of your 500 GB of storage so make 'em as big as you want.
Shell access. We're talkin' SSH. (Well, if I could figure out the damn certificate thingy.) I'm using 'ln -s' to create symbolic links for the first time in 6 years. Reminds me of college...
The deal-maker: SVN. For those that don't mind (or prefer) OSS source control, this is it. I use it for all of my code and personal writing--all things I want to backup, sync reliably across machines, and keep version history on. I'll post later on my love of Tortoise.
Oh, and they're carbon neutral. It's almost silly.

I said almost above. What's the catch?

Well, there's not a huge number of easy-to-install software packages. They don't use cPanel/Fantastico like a lot of Linux hosting shops. The interface they do provide is very clean and one can manually install most things, but it's kinda nice to do a click-and-install for Drupal.

That's my only nit, actually. Everything is super fast. I'm super happy.

Check 'em out.

But Kevin, this is a Linux hosting package. Where's the Windows Server 2008 package?

Sigh. The world is so much larger than the Microsoft stack of technologies. I love VS as much as anyone, but getting a broad skill set is important, right? Plus the OSS web community is insanely strong. The content, energy and enthusiasm are amazing.

Full disclosure: Yes, the links provided are for a referral program. Yes, I get a kick-back if you sign-up. No, I would never pitch anything just for the kick-back.

I've had plenty of services offer kick-backs that I blinked at--that I never felt strongly about. This is proof I have no subtext. These guys are that good.

In search of DRY SPOT

2007-12-04T10:06:00.001Z

I realized there is a concept I come back to often in a lot of my software implementation and in a lot of my discussions. It goes by two common acronyms that are pretty much interchangeable.

DRY: Don't Repeat Yourself.
SPOT: Single Point of Truth.

DRY is articulated in the book The Pragmatic Programmer, although Eric Raymond likes to call it SPOT.

How does this exist in our world of C# and .NET? Well, every time you define a private const string or private const int instead of sprinkling magic values all over your code, every time you generate documentation from your source files, every time you develop a clever data structure to represent both the execution and the description of a process, you are practicing SPOT.

Quite often, my SPOT will live in a static class Util that I create for almost all of my software projects. If I have one way to handle errors, one pay to deal with collection, one way to handle user input, centralizing it makes bug fixing so much easier. It actually minimizes bugs in a lot of cases, which minimizes the need to fix them.

If you haven't heard of these concepts, they are great to add to your software vocabulary.

For many, I'm sure the idea has always been floating around, just without a good name.

Now you have a good shorthand when you are mocking someone else's code.

Happy hacking!

Reasons to subclass: Great, Good, Okay

2007-11-22T02:11:00.001Z

Shout-out to brilliant developer (and my co-worker) David Potter, who--through hours of discussion--helped me arrive at this 'thought'.

FYI: I use a lot of WPF examples in here. Apologies to the non-WPF devs.

Back in June, I wrote a post titled: Don't subclass a Panel, unless you're making a Panel.

In that post, I outlined the 'great' reason to use subclassing (read, inheritance):

I read a great internal paper at MS once--written by one of those brilliant old-guard devs with decades of perspective. The point the author pushed: use inheritance only for polymorphism. Translated: when making MyGrid, only subclass Grid if you mean for people to treat your new MyGrid just like another Grid. Code (and a user, for the most part) that deals with Grid should be able to "deal" with MyGrid without any issues.

I use a strong word there: only.

Now with time and experience comes perspective.

I'm going to make this philosophy a bit more nuanced by introducing categories of subclassing: great, good, and okay.

My argument: there are times to use each, but the further you get away from 'great', the more trouble you can get in and the more careful and thoughtful you should be.

Great subclassing: for polymorphism.

Examples here: Stream (from mscorlib) and UIElement (from WPF).

Stream is worthless by itself. It's meant to be the base class for something else. But there are innumerable features of the CLR that deal with Stream generically, without much concern for any subclass.

UIElement is similar. Basically worthless by itself. Designed to be a baseclass. But things like WPF layout (Measure/Arrange) deal explicitly with UIElement, ignoring any details of any subclass.

If you create a Foo class and have other classes that take a Foo in a constructor or method argument, even though Foo is abstract or rarely used by itself you are playing in the 'great' end of the subclassing spectrum.

Good subclassing: cognitive simplicity

If 'great' subclassing is for software components, 'good' subclassing is for humans.

ContentControl (WPF) is a pretty good example. I can't think of any constructor or method that takes ContentControl as a parameter.

We could imagine Button and Label and ScrollViewer all re-exposing the common properties (Content, ContentTemplate, ContentTemplateSelector) without any changes in functionality.

But! It's really nice that users can look at Label and say "oh, that's a ContentControl" and immediately have a valid mental model of how to use it.

The baseclass, in this respect, provides a grouping paradigm for a user to understand classes of types.

While this is a nice feature, it has its issues.

ButtonBase is a good example.

ButtonBase is the 'clickable' widget in WPF.

Almost everything that is clickable subclasses ButtonBase.

ButtonBase subclasses ContentControl.

ContentControl is the 'content' widget in WPF.

Almost everything in WPF that has content is a content control. Well, almost. ContentPresenter has the same properties that ContentControl has regarding content (Content, ContentTemplate, ContentTemplateSelector).

But they don't share a baseclass. Why?

Well, because ContentControl is a Control.

Control is the 'template-able' widget in WPF. It lets you swap out the chrome.

ContentPresenter doesn't let you swap out the chrome, just the template for the data.

So, we could really imagine three separate classes, all of which derive from FrameworkElement.

ClickElement: exposes the click properties/methods/events.
ContentElement: exposes the content properties/methods/events (Yes, this class name already exists for text stuff. Play along...)
TemplateElement: exposes the template properties/methods/events (this is what Control is now).

The fact that ButtonBase subclasses in a specific order is kinda arbitrary.

One could imagine wanting a template-able, click-able element that doesn't have content.

One could imagine wanting a click-able, element that holds content that isn't template-able.

Single inheritance forces framework authors to choose. This can be annoying if you want a re-mix of the available features.

A great example of this: TransitionPresenter (from the bag-o-tricks).

It has all of the content properties, but it's not a ContentPresenter or a ContentControl. (The way it does its visual tree is different than both of those controls.)

It turns out to be impossible to subclass ContentPresenter and it's confusing to subclass ContentControl (because TransitionPresenter doesn't use a ControlTemplate).

A really smart dev who was doing code clean-up actually changed the baseclass from FrameworkElement to ContentControl, thinking he was making things simpler.

This is bad! A user will then expect to be able to use the Template property to change the chrome. This is the same problem with making MyGrid from Grid unless you want people treating it like any other Grid.

This trap is usually because of the third type...

Okay subclassing: tactical code reuse

If you have 15 classes that all have a Foo, Bar, and Baz property, having a common baseclass just saves code. Less to document. Less to test. Less to mess up.

Fine.

But if sharing some common state is your only goal, just make sure you acknowledge (along with the rest of your team) that is why you're doing it. Put it in the code comments of the class.

In some respects this is less dangerous than the 'good' reason to subclass because the FooBarBaz class probably doesn't have much meaning or use beyond your tactical reasons. As soon as it does, though, you can fall into the MyGrid trap.

In closing

This was a really long write-up.

I guess my final advice is be careful.

As with anything in life, if you try to be clever for clever's sake, you'll get burned.

If you try to use every feature of a language or a framework just to add spice to your afternoon of coding, you'll get burned.

As I discussed in my post about patters and guidelines, always try to understand the implications of the tools/tricks you use when coding.

And that's all I have to say about that.

Happy hacking.

Did you find this interesting? Let me know. I'd hate to think I was riffing all this out just to make my tendinitis worse.

.NET 3.5 is here; IDataErrorInfo support in WPF seems to be popular

2007-11-21T07:41:00.001Z

One of the things that sucks about being on the outside is the surprises.

I was blown off my chair when I heard .NET 3.5 released yesterday.

I talked about some of the new stuff in August.

My favorite feature (that I designed, at least) was IDataErrorInfo support in WPF data binding.

Rocky likes it.

Walk likes it.

Even God likes it. ;-)

You really should be thanking Dr. Bent, who made it.

And Bea, who made sure it worked.

Going beyond Monitor.Enter/Exit (C# lock) with LockHelper

2007-11-14T05:13:00.001Z

Sample code: LockHelper.cs [6KB]

Debugging threading issues is painful.

Really painful.

One of the most painful problems: dealing with deadlocks--waiting forever on a Monitor.Enter (C# lock) and not knowing which thread already has the lock.

I tried to dig in on this on the CLR Base Class Library Forum. I was hopeful, since Java has a method [Thread.holdsLock(obj)] that returns the holder of the current lock

Sadly, .NET lacks this functionality.

Enter a can-do attitude: why not build it myself.

Enter LockHelper.

Goals:

Identical semantics to Monitor.Enter/Exit
Enable other Monitor features (Pulse, Wait)
Close to identical syntax to C# lock
Ability to know, given an instance of LockHelper, the current owning thread
Other conveniences (CheckAccess and VerifyAccess)

Wrapping Monitor.Enter/Exit isn't that hard. As you see with the implementation, it's pretty easy to leverage IDisposable + the C# using statement to get syntax that is close to lock.

Instead of:

public void Foo()
{
    lock(m_lockObject)
    {
        //do stuff
    }
}

private readonly object m_lockObject = new object();

Do this:

public void Foo()
{
    using(m_lockObject.GetLock())
    {
        //do stuff
    }
}

private readonly LockHelper m_lockObject = new LockHelper("foo");

GetLock() returns a private class that implements IDisposable. The using block has identical try/finally semantics to the lock keyword. (See this article in the C# Programming Guide for details.)

I had to be religious about storing away Thread.Name for the current thread at all times. While debugging, I found that VS was often unable to evaluate the property of the owning thread.

So now I have enough plumbing to figure out which thread has a lock on my lock object. Cool.

What else?

Exposing Pulse and Wait was pretty easy. Beyond these basics, I stole the CheckAccess/VerifyAccess ideas from WPF.

Often times one will have private helpers in a class that access/modify the state of a class. Often times these methods (should) run under the assumption that they were called in the context of a lock.

The simple way around this is to re-lock the object inside the helper method, but this can be a source of deadlocks and really doesn't help maintain the implementation contract.

What one wants: a way to assert that the calling thread owns a lock.

Done!

CheckAccess returns true if the current thread has the lock. Otherwise, false.

VerifyAccess goes a step further and throws an exception if the calling thread doesn't own the lock.

Pretty cool, huh?

Note: I was not on the CLR team at Microsoft. I was not a developer at Microsoft, just a lowly PM. I'm pretty confident this works. At least I haven't hit any issues with it. Please be careful throwing this in your own projects. This is certainly out of the realm of advertised best-practices from MS.

It works for me, though.

Let me know what you think.

Happy hacking!

The event pattern in C# and funny coincidence

2007-11-03T19:59:00.001Z

On Thursday, I wrote about the importance of software patterns, specifically the event pattern in C#.

That very afternoon I was going through some code written by a co-worker that leveraged this pattern.

To keep things simple, let's imagine it was like this.

public event EventHandler NewMessage;

protected virtual void OnNewMessage(MessageEventArgs args)
{
 EventHandler handler = NewMessage;
 if(handler != null)
 {
 handler(this,args);
 }
}

protected virtual void OnNewMessage(string message)
{
 EventHandler handler = NewMessage;
 if(handler != null)
 {
 handler(this,new MessageEventArgs(message));
 }
}

Pretty straight forward, right? See the problem?

This gets to the core of why understanding a pattern deeply is important. The pattern of having a protected virtual OnFoo method for your Foo event is to ensure that a subclass can peek at the event before it's fired. The implementation above will require the subclass to not only override both methods, but to understand that she must override both methods to make sure all raised events are captured.

This is making the job of the subclass writer much harder and likely more error prone.

I'm not saying one should get rid of the helper method. It's fine. It just needs to be tweaked.

protected void OnNewMessage(string message)
{
 OnNewMessage(new MessageEventArgs(message));
}

First, get rid of the virtual flag. This should be callable from a subclass, but there should only be one method to override.

Second, call the 'real' virtual method from the helper. This ensures that anyone who overrides OnNewMessage will get the desired result.

A clever developer might not like this, because she wants to avoid allocating the EventArgs unless there actually are handlers to call. Clever optimization, but it breaks the pattern.

Make sense?

Happy hacking.

Former MS co-workers done well: Amar & Robby [Videos]

2007-11-03T02:55:00.001Z

Amar was my GPM (manager's manager) in the Longhorn days. (Yes, back when Vista had a lot more managed code and was going to change the world.)

He's one of the stars in the intro video for Google's openSocial. (Look for the Indian guy in the Brazilian soccer jersey.)

I can't wait to start hacking on this stuff.

The last time you may have seen him on video was when he was GPM of the RSS team at Microsoft. (Interviewed by Scoble, none the less. A lot can change in three years, huh?)

Robby is on channel9 again, chatting the goodness of the 'integrator' role in WPF/Silverlight development. He's a main guy at identity mine these days.

Robby and I worked together on the WPF team in the v1 days. The last time you may have seen him on channel9 was with yours truly. Although I'd rather forget the topic. :-)

The importance of patterns and guidelines in software development

2007-11-01T16:39:00.001Z

I've been pulling my hair out on IDisposable, Dispose() and protected virtual Dispose(bool disposing) the last 24 hours.

I think I've figured it out. Finally!

I started writing a whole entry on it, but then I realized there is a whole prequel that needs to be written first. So...

We're talking about patterns and guidelines for software here, my friends. They exist to ensure consistent behavior and therefor consistent expectations. This is for direct users of your classes and also those who subclass your classes. The problem with patterns, though, is that they become customs. We do them without asking why we do them. Then we start questioning why we do them if we don't fully understand. We might even start tweaking them if they get cumbersome, which can cause unexpected consequences later on.

So it's always good to understand why (at least at some level) we implement a pattern.

My favorite example: events.

So you add a public event to your class:

public event EventHandler Updated;

And because you were told to, you implement:

protected virtual void OnUpdated(EventArgs args)
{
 EventHandler handler = Updated;
 if(handler != null)
 {
 handler(this, args);
 }
}

Like a robot. Do yo know why? Really?

Q: Why protected?
A: So a subclass can raise your event. The C# compiler is doing work behind the scenes. You don't see that the event really has both public and private surface area. Only the class that defines the event can raise it directly.

Q: Why virtual?
A: Because a subclass might want to intercept the event and take some action on it. It's cumbersome for a subclass to register an event listener on itself.

Q: Why create the 'handler' field in the method? Seems like a waste of a variable.
A: Threading. To ensure that between the check for null and the call, the event hasn't been unregistered. (But I don't have multithreaded stuff in my library, you say. Right. But might you tomorrow? Might a subclass? Might a direct user of your library?)

Q: Why not simplify the method signature to take no parameters? EventArgs is empty, right?. I should just handle that in the method, right?
A: No. Some subclasses might want to pass a different EventArgs to the method. They might want to pass more information via FooEventArgs. If you lock down the method signature, you are locking them out of extensibility. (Working on WPF, we actually got a bug about this with OnCollectionChanged in ObservableCollection).

See! Such a simple pattern, yet so many nuances!

You might do this work even if you haven't imagined any subclasses. You are doing it just in case.

In fact, the only good reason not to do this work is if you seal your class. Even then, what if the class gets unsealed in the future? Will you remember re-implement the pattern the right way?

Better to do it correctly from the start.

I need to get some work done now. In the next day or two, I'll post my discoveries on IDisposable.

In the mean time, ask yourself: am I cutting corners with patterns? Am I implementing patters which I don't fully understand?

Hmm...

Happy hacking.

Threading fun: Monitor.Wait, Monitor.Pulse

2007-10-26T21:02:00.001Z

Threading is pretty scary. An solid grasp of threading, as a brilliant dev lead at Microsoft once told me, was one thing that consistently separated the "men/women from the boys/girls" in the engineering discipline.

Here's my attempt to sound adult. (Forgive me if my voice cracks.)

The Scenario: You have a bunch of threads running around doing work--in this case, adding random numbers to a collection. You have another thread with the aggregation job: take all of the numbers in the collection, add them to a running total, and clear out the collection.

This is a simplification of a problem I was faced with on my current gig: handle multiple "users" via separate WCF connections (coming in on separate threads). Aggregate their work requests and process them on a 'worker' thread. All while staying super responsive.

So you always have the one thread that's waiting around for work. How does it wait? The simple answer would be a while-true loop that's always polling.

That'll peg a thread pretty quick while doing a bunch of unneeded locking of your synchronization object. One could add some sleep statements to the loop to minimize the impact, but that feels like a bandage.

What one wants: a way to have the processing thread "wait" to until there actually is work to do.

Enter Monitor.Wait and Monitor.Pulse.

Mike Woodring does a pretty good job of explaining this (with a very funny title/analogy), but I really wanted a fully baked and un-contrived code sample.

So here it is. In exactly 100 lines of code.

MonitorWaitPulseFun.cs [3KB]

Wait and Pulse both must be called in the context of a lock (Monitor.Enter/Exit) for the provided object.

Wait [Line 58] basically gives up the lock (and allows other code blocked by the lock to run) and waits until Pulse [Line 43] is called on another thread. The 'wait' thread then gets back in line for the lock and continues execution from where it left off.

It's a bit weird to accept that a lock for a given object is temporarily given up between the curly braces, but that's what happens.

The only hiccup I ran into was realizing that one really needs to be careful to make sure pulse is called enough, especially when shutting down. 'Wait' will wait forever if it doesn't get kicked.

A note: I go this all working with a WaitHandle initially (specifically, AutoResetEvent), but I realized it was a lot more involved and (after some research) a lot heavier than I needed. WaitHandle actually wraps some Win32 stuff that goes way beyond what I need for this scenario.

Anyway, here's my foray into non-WPF technical blogging.

Interesting? Helpful?

Happy hacking...

Hello MSDN Mag Readers

2007-10-17T20:20:00.001Z

I kinda forgot I wrote this article in August.

I guess the sudden increase in emails makes sense.

In case it got buried, I am no longer at Microsoft, but you can still find the bag-o-tricks here.

I've taken a pretty big break from most things WPF. If you have questions, you're best bet is the WPF MSDN forum.

Hope you enjoyed my attempt at wit and wisdom.

I'll avoid any reference to rats and ships

2007-10-06T01:28:00.001Z

On Monday, Fil made a note on Facebook listing the ~10 people he knew who had left MS this year. After a couple days and a few additions from friends, it was up to 16.

Earlier today I stumbled upon Rory's announcement.

Then I discovered Danny's post.

Wow.

Maybe it's just that time of year.

Maybe it's that departures are more visible these days.

To use Microsoft's favorite overloaded statement: interesting.

What I install on a new machine: Free apps

2007-09-22T21:41:00.001Z

Starting the new job, you start with a new machine. I thought it would be interesting to go through my 'bag-o-tricks' as far as what I install.

These apps are free. Some are free as in beer; some are free as in speech (or as Stallman says, free as in freedom).

I'd love to know what other people have in their must-install list for a new machine. I might be missing something awesome.

Windows Live Messenger & Writer: http://get.live.com/wl/all

Still going strong with two great apps. My humble requests:

Messenger guys: please save my preferences on the server. I hate re-configuring tabs, welcome screen, contact grouping, sounds, etc.
Writer guys: please fix your support for images in Blogger. This is my only complaint.

Paint .NET: http://www.getpaint.net/

I will admit to frequently lusting after a licence to Adobe Photoshop. No longer. An amazing app that just keeps getting better and keeps staying free. Awesome.

.NET Reflector: http://www.aisto.com/roeder/dotnet/

If you code .NET, this gets installed before VS. Amazing. Also keeps getting better.

Firefox: http://www.mozilla.com/en-US/firefox/

Yes, I'm one of those guys.
Yes, I have friends that work on IE.
Yes, I wish them well.

But...

I believe in open standards. The only way to protect and encourage open standards is to have many prevalent implementations of said standards.

Firefox is just better. Even when it crashes, it remembers where I was flawlessly...something IE never does. It scales web sites in a (more) rational way. The extensibility is also amazing, as I share below.

Greasemonkey: https://addons.mozilla.org/en-US/firefox/addon/748

What a clever concept. I really only use it for one script, though. Would love to know more good ones.

Google Secure Pro Greasemonkey Script: http://userscripts.org/scripts/show/5951

Later, I will go through all of the web apps and services I use, but here's a hit: I use a lot of Google stuff.

Google supports HTTPS (SSL) on most of it's properties, but not by default. You have to put https:// manually in the URL.

This script does that automatically for a whole host of Google properties. It's also extensible for any web site. (Like sneakemail, which I'll go into in another post.)

Flash Blocker: http://flashblock.mozdev.org/

Another great Firefox add-on. This one replaces all flash content with a little arrow. When you press it, the flash loads but not before.

Great for seeing only the content you want to see and nothing else.

Sumartra PDF: http://blog.kowalczyk.info/software/sumatrapdf/

See my comment about many implementations of open standards. This is a solid client. It doesn't support all of the bells and whistles of Adobe Acrobat, but it's super small and doesn't install any tray icons or run any background services. Kudos.

Skype: http://www.skype.com/

Great for chatting with the folks and the brothers.

My parents are doing video conferencing.

Scary.

Notepad++: http://notepad-plus.sourceforge.net/uk/site.htm

You can guess: a better version of notepad. Much better.

Support for syntax highlighting for multiple formats (C#, Xml, Ruby, etc.), a convenient shell context menu, tabs, the whole sha-bang.

I discovered this years ago. It keeps getting better.

For those times when you don't want to wait for VS to load.

Process Explorer: http://www.microsoft.com/technet/sysinternals/Utilities/ProcessExplorer.mspx

Last, but not least.

Ever want to delete a file and not know which process was keeping it open? This is the tool.

From our friends at SysInternals (that are now our friends in the Windows Kernel team).

What did I miss?

I'd love to know about *your* bag-o-tricks. I'll re-post anything I find useful.

Share the love and have a great Saturday.

I'm leaving Microsoft

2007-09-14T07:15:00.001Z

You read that correctly. September 14 is my last day at Building 10 on the Redmond Campus (well, at least as an employee).

Here is (most of) the goodbye email I sent to colleagues and friends last week.

Where to start. Iowa State. Fall of 1998. A career fair. I was a freshman looking for free stuff. The MS recruiter wanted to see a resume. I didn’t have one. (I didn’t think I would need one.) I ran back to my dorm, wrote enough to fill a single page, and brought it back to him.

Early that spring I flew to Sea-Tac and had an on-campus interview. (I was warned that that winter had 100 sunshine-less days.)

In May 1999 I showed up in Redmond for an internship. Building 25. I shared an office with a woman who’s a great friend to this day.

After 3 internships, a stint as a Microsoft Student Consultant at ISU, and 5 great years as an stock ~~option~~ award earning employee, I’m going to try something drastically different.

Friday, September 14 will be my last day in the office.

Monday, September 17 I’m going to work at a small, actuarial company building internal, web-based LOB apps.

No, I’m not crazy. (At least I don’t think so.) It’s been almost a decade since I’ve built anything substantial end-to-end. I’ve got pretty good at designing the tiny pieces of something XXXL. I’d like to try my hand at implementing a huge pieces of something M.
Yes, I’ll be staying in the area. Actually, working from home most days.
Yes, it’s all .NET still. I’m actually looking forward to cranking on SQL, ASPX, WCF, Workflow, Linq, ADO Entities, etc.
Yes, it’s hard to leave. I’ve been plugged into Microsoft since just after high school. It’s been a great ride. I’ve learned an amazing amount and met some amazing people. Recently though, I’ve realized that if I was ever going to unplug, it was never going to get easier than it is now.

http://j832.com is my web site. It mostly just links to my blogs. I plan to keep work.j832.com going for any WPF stuff I hack on. The other blog will be everything else. :-)

(If you want the j832 thing explained some time, just ask.)

I have two closing thoughts.

First, Doug Purdy shared a tag line that Don Box and he used on a presentation once: “There is only one program…and it’s still being written.” Microsoft was a gig. My new company is a gig. There will be gigs after. The gig is not the important thing. It’s the stuff you’re building. I love software because in the end it’s all about helping people record, explorer, and communicate thoughts, memories, and ideas. If we keep making that faster, easier and just better we will all still be working together...and making the world just a bit better.

Second, a video I discovered a couple months ago. While it was after I’d made most of my decisions, it does a good job of representing the stuff in my head right now…the stuff I’m trying to figure out. It’s absolutely worth sharing: http://blog.j832.com/2007/07/music-and-life.html

I will close out the way my good friend Robby did. A master of great design: simple and to-the-point.

Goodbye and thanks again,

>Kevin

Q: What does this mean for me, loyal reader of work.j832.com?
A: Hopefully not much. I plan to keep working with and blogging about WPF. I have some clever project ideas that I still want to hack on. A cool upside: I can actually collaborate in substantial ways with community members. I may blog a wider variety of stuff, but given the new job I'm sure it'll be mostly .NET-related. I'll keep my non-geek stuff on my personal blog: blog.j832.com.

Q: What about the bag-o-tricks?
A: The current URL (blogs.msdn.com/okoboji/pages/BagOTricks.aspx) is going to die when my MSDN blog dies. (I'm not sure about when that'll happen, actually.) So I'm introducing a new, even more stable home for the latest-and-greatest: j832.com/BagOTricks. I hope this will be valid as long as I remember anything about WPF and I pay my ISP bill.

Q: Are you planning any updates the bag?
A: Great question! I can't say much, but...um...expect great things from a lot of what's in the bag. (This is my subtle and evil way of leaning on Larry. Sorry dude.)

Q: What about the NetFX install stuff?
A: I'm going to hand this off and make sure that those who've emailed me are taken care of--hopefully by making the code generally available.

As I've said to many folks, I'm looking forward to the transition from a Microsoft High Priest for WPF to just another geek in the big city.

See you on the other side, my friends.

Video: What's new in WPF for "Orcas"/3.5/VS 2008

2007-08-09T18:43:00.001Z

While it's not KevinButton, I do spend some time walking through what's new and what's better in our next release.

Thanks to Charles and Tim for coming over.

Not the best picture of me. Maybe I should have shaved. You can see the fireworks from Lake Okoboji in the background, though.

Enjoy the video!

Gnomedex 7.0: I'm going

2007-07-19T07:22:00.001Z

5 tickets left when I signed-up.

See ya'll there.

Making NetFX Framework + Application install easier

2007-07-16T22:41:00.001Z

Do you deploy the .NET Framework 3.0 with your application installation? Would you like a better experience for your users with framework + application installation?

The WPF team has done some work to make this process easier for both application authors and end-users.

Before we make the code generally available, we'd love to have some folks give it a dry run.

Drop me an email if you'd like to give our code a test drive or if you have questions.

We're hoping to make the install part of your app experience more enjoyable for everyone.

WPF and CSLA (and subclassing Panel)

2007-06-26T17:06:00.001Z

From Rob's blog, I found a discussion about WPF support in CSLA.NET, specifically what to subclass for the containers.

I haven't played w/ the DataPanelBase, as it's discussed, but I'd be curious what Rockford would say about my discussion on subclassing panel.

If he's building a container to host arbitrary UI, but the user may want an arbitrary layout, I would push for Decorator. This would allow the user to specify any panel she wants.

A bit more Xaml is an okay trade-off to ensure a clean object model and straight-forward usage semantics.

As Rob mentions, Window and Page are great examples of generic containers that only support a single child.

StackPanel is particularly bad since it will give it's child an infinite measure/arrange in the vertical direction. This is really bad if you put in an ItemsControl because it will take up as much space as needed to render all of its items. This could both mess up the UI and slow things way down--virtualization doesn't help much if all of the items are visible.

Rob and I hang out too much (RE: a good URL for the bag-o-tricks)

2007-06-26T01:35:00.001Z

All of an hour ago, I made a post trying to bring sanity to the problem of finding the latest bag-o-tricks.

Looks like Rob thought of this 4 days ago.

Great minds, right?

Or maybe I should just keep up on my blog reading.

RE: CompositionTarget.Rendering

2007-06-26T01:07:00.001Z

I use CompositionTarget.Rendering a lot in the bag-o-tricks. (Last count: AnimatingTilePanel, Graph, ZapDecorator, and FlipTile3D.)

Rob posted to an internal discussion about how to use (and how not to use) the event. (I saw a link on WiredPrairie as well.)

Specifically, it's important to remember this is a timer that ticks all of the time--every frame--potentially 60 times a second or more.

Since it's a static event, it will keep firing even if control you use it in isn't on the screen any more.

Hence, it's critically important that you manage the use of this event appropriately.

Un-register the event when your control is unloaded. I actually add a handler for the Unloaded event in my controls to do this. If you don't do this, events will still be fired to your delegate, even if the control is removed from the visual tree! This is not only a perf hit, but could introduce crazy behavior, crashes, data loss, mass hysteria, etc.
Potentially un-register the event when the UI isn't visible. Like when the window is minimized. Be careful, though. Finding window state from a control could be ugly. You also may want to let your animation run its course even if it's not visible, which leads me to the final bullet...
Un-register when your animation "settles". Since I used the Rendering event for my physics models, I do this when I reach equilibrium. Once all of the forces have balanced out and stuff stops moving, I un-register the event (and make sure to re-register once something changes that will start things moving again).

Users don't like their CPU pegged (unless something really cool is happening). A user with a dead laptop battery is not a happy user.

Happy hacking!

Keeping track of the Bag-o-Tricks

2007-06-26T00:26:00.001Z

As I update the Bag-o-Tricks, I wanted to keep one URL for people to check to make sure they have the latest hotness.

(This is a nod to Rob's Url Manifesto. While I pick on him a lot about this, I think it's a great way to think about the user model for the web.)

Anyway, I'll keep this page updated with the latest info on the bag-o-tricks. (And, hopefully, a description of each demo/sample when I get some free time).

I'll have some updates soon, I promise.

A great way to learn a programming language

2007-06-19T18:27:00.001Z

I'm sure many have heard discussions about the DLR and IronRuby coming out of MIX07.

As a guy who cares about great developer experiences and great user experiences, I've also paid some attention to Ruby on Rails.

So last night, I thought I'd dig in.

Instant Rails seems to be a popular place to start. A one-stop-shop for Ruby + Rails + Apache + MySQL. All runs on Windows by just extracting a zip file. (The only hiccup I encountered was making sure that port 80 was available.)

After I got things running and clicked around a bit, I realized I was trying to learn Japanese by picking up a book and trying to cross reference concepts to a Japanese-English dictionary.

Not very effective.

What I needed was a "vocabulary" and "grammar" introduction. (In quotes, because I'm referring to my Japanese analogy and not programming language constructs.)

After the obvious search term--"ruby tutorial"--I stumbled upon an amazing tool: Try Ruby.

Holy cow! A ruby interpreter in-browser. A great way to understand the language. I had a bit of trouble dealing with mistyped lines, but otherwise, it's an amazing tool.

More programming languages should be presented this way.

This is certainly worth a few hours on a Tuesday night.

Kudos to the developers.

Ya'll reading the WPF SDK blog, right?

2007-06-18T22:10:00.001Z

People are always looking for deep content on WPF. This is a great source: http://blogs.msdn.com/wpfsdk/

Carole is an SDK writer that frequently digs in with those of us on the engineering side to make sure the SDK blog is speaking the truth.

Check it out!

Don't subclass a Panel, unless you're making a Panel

2007-06-10T21:02:00.001Z

I have a tongue-in-cheek thing I say a lot about WPF compared to Windows Forms:

In Windows Forms, there are two ways to do everything: a good way and a bad way.

In WPF, there are ten ways to do everything: two that are amazing, 3 that are good, 1 that is bad, and 4 that suck.

My goal in this post is to help move people upstream towards amazing, specifically how and when to use Panel (and its subclasses).

Markup subclassing

Everytime you go into VS and create a new WPF project, you see markup subclassing. This is the Window x:Class="WPFApplication1.Window1" stuff. It allows you to associate a piece of XAML to a subclass you define in Code. There are four approved places you'll see this in WPF: Application, Window, Page, and UserControl.

More than once, though, I've seen clever people (both outside and inside Microsoft) take this approach one step further. They want to reuse a piece of UI several times. Maybe they have a Grid defined with a set of columns, rows, and controls defined. It's pretty easy to take that Xaml-defined Grid (with all of its XML child elements), put it in it's own Xaml file, slap on an x:Class statement and start rolling. Things work great.

Rock-n-roll, right?

Well, not really.

Inheritance for polymorphism

I read a great internal paper at MS once--written by one of those brilliant old-guard devs with decades of perspective. The point the author pushed: use inheritance only for polymorphism. Translated: when making MyGrid, only subclass Grid if you mean for people to treat your new MyGrid just like another Grid. Code (and a user, for the most part) that deals with Grid should be able to "deal" with MyGrid without any issues.

Where things break down

So let's say you define your BadGrid Xaml like this (with an associated BadGrid.xaml.cs file with properties, events, etc):

<Grid x:Class="PanelFun.BadGrid"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
 <Grid.RowDefinitions>
 <RowDefinition/>
 <RowDefinition/>
 <RowDefinition/>
 </Grid.RowDefinitions>
 <Grid.ColumnDefinitions>
 <ColumnDefinition/>
 <ColumnDefinition Width="100"/>
 </Grid.ColumnDefinitions>

 <Label Grid.Row="0" Grid.Column="0" Content="_First Name" Target="{Binding ElementName=FirstName}" />
 <TextBox Grid.Row="0" Grid.Column="1" Name="FirstName" />

 <Label Grid.Row="1" Grid.Column="0" Content="_Middle Name" Target="{Binding ElementName=MiddleName}" />
 <TextBox Grid.Row="1" Grid.Column="1" Name="MiddleName" />

 <Label Grid.Row="2" Grid.Column="0" Content="_Last Name" Target="{Binding ElementName=LastName}" />
 <TextBox Grid.Row="2" Grid.Column="1" Name="LastName" />

</Grid>

Looks okay, right?

Let's use it.

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="clr-namespace:PanelFun">

 <local:BadGrid/>

</Window>

Run the app. No problem!

Now let's say a naive user (maybe someone in your company or a customer) takes your control and sees that it's a Grid. They write this Xaml:

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="clr-namespace:PanelFun">


 <local:BadGrid>
 <Grid.RowDefinitions>
 <RowDefinition/>
 </Grid.RowDefinitions>

 <Label Grid.Row="3" Grid.Column="0" Content="_Favorite Color"/>
 <TextBox Grid.Row="3" Grid.Column="1" />
 </local:BadGrid>

</Window>

Things compile fine. They are using BadGrid just like a Grid. No problem, right?

The problem, of course, is that you didn't mean people to use BadGrid like a Grid. You wanted them to use it like a simple Control. Weird things happen, dogs and cats living together, mass hysteria.

In this case, you get the user-created row inserted into your grid. If the user tries to put a name on the TextBlock, the compiler blows-up because of naming conflicts between the definition scope (in BadGrid.Xaml) and the usage scope (in the Window). The user has no clue why things blew up. (I'm not all that sure myself, actually.)

If you want to use markup subclassing, stay inside the fences

Application, Window, Panel, UserControl. It's pretty simple to paste your desired Xaml into a UserControl, with no unplanned weirdness.

If you want to extend markup subclassing further, we should talk to Rob. He's the Xaml guy. :-)

If you want to do any subclassing, pick the right base class

In general (even if you're not using Markup subclassing), make sure you "mean it" when you use inheritance in WPF (or any object orientated framework, for that matter). If you subclass a ContentControl, do you mean people to treat it like a ContentControl all the time? Same thing for ItemsControl, Decorator, and Panel.

When would I subclass a Panel?

Well, if you want to make your own panel, start with Panel. AniTilePanel from my bag-o-tricks is a good example.

You might want to subclass a bit deeper, but only in special cases.You could make OrderedStackPanel, where you introduce your own AttachedProperty: OrderedStackPanel.Order. This can be applied to items and your panel will order the items in the stack based on the property. The cool thing: without the property set, your panel should act just like StackPanel. This holds to the theory about inheritance and polymorphism.

Make Sense? Sound good? Hack on!

What are you doing to protect the Internet?

2007-06-10T19:30:00.001Z

For more information: http://www.savetheinternet.com/

To promote the cause yourself: http://www.savetheinternet.com/=promote

Jobs & Gates

2007-06-03T22:02:00.001Z

We've heard a lot about the meeting of Steve Jobs and Bill Gates.

9 Parts, I'm through part 3...cool stuff, via YouTube.

Caution: Surface is very hot

2007-05-30T06:27:00.001Z

http://www.microsoft.com/surface/

Let us talk about hotness. Holy hotness.

I've never jumped up and down and laughed out loud more than when when I got to play with Surface.

Scary-beyond-words cool stuff.

I've been delighted to help the team with a few tweaks to WPF core controls to ensure they play nicely on Surface. It's a great showcase of the power of our platform (and a number of other MS graphics technologies.)

Actually, very few tweaks were needed to WPF to support their scenarios. Dwayne and friends did an amazing job designing an extensible input system. Mouse, keyboard and stylus were on the initial list of possible devices. Finger and drink glass just happened to plug in nicely.

Here's to brilliant layering, huh?

20 Steps to happiness

2007-05-30T05:59:00.001Z

(This silliness assumes you haven't jumped into the beauty that is WPF development. It also assumes you're running Vista. If you aren't, why not? If you have a good reason, I'm betting you'll get help installing .NET Framework 3.0. on XPSP2)

Go here
Click on Visual C#
Login with your Windows Live ID
Download and click on all of the nessesary buttons
Marvel at the small (~30 MB) download (if you don't get the data stuff).
Type "Visual" in Vista's start menu.
Marvel at the cool search feature
Pick Microsoft Visual C# 9.0 Express Edition
Marvel at our crazy long product names
Pick "New Project..." from the start menu. (Ctrl+Shift+N to be super fast)
Pick WPF Application.
Marvel at the visual designer for WPF. (Thanks Cider team.)
Open up the Toolbox and find the ListBox under Common Controls.
Draw out a ListBox on the Window.
Marvel at the XAML updating right away.
Notice the auto-generated name for your ListBox: listBox1.
Open up Window1.xaml.cs
Paste the following below InitializeCompontent();

var foo = from a in Directory.GetDirectories(@"C:\") select new{a, a.Length};
listBox1.ItemsSource = foo.ToList();
Marvel at:
-the use of "var" -- mmm...implicit types
-from/select in C# -- mmm...Linq goodness
-new {a, a.Length} -- mmm...anonymous types
.ToList() -- mmm...extension methods
Hit F5

WPF Goodness + VS "Orcas" design-time Goodness + Linq goodness = happiness

mmm...

My Mix Session is finally live

2007-05-25T18:48:00.001Z

Well, it's been live for a while, but I was in Iowa last week.

XD009 - WPF For Developers

As I said before, the code for all of the demos is in the bag-o-tricks.

Happy hacking!

Kevin's Bag-O-Tricks - MIX07 Edition

2007-05-02T16:52:00.000Z

For those that came to my talk, thanks! Please fill out an evaluation so I know what you liked.

For everyone, as promised, here's the updated bag-o-tricks.

Drop me an email if you have questions/comments/bugs/suggestions.

MIX07, here I come!

2007-04-29T01:32:00.001Z

I fly out tomorrow morning for Mix07. I've been cranking for a week on my slides and demos. They feel pretty good.

The public list of sessions is here. We've done a bit of churn in our talk format. Rob and I are both riding solo. This is mine.

XD009, Windows Presentation Foundation for Developers – (Part 2 of 2), Wednesday 11:30-12:45, Lando 4204

Be the first to get your hands on the update to the bag-o-tricks. For those not coming, just watch this space. I'll get them posted publicly shortly after my talk!

I have some good friends giving talks you should check out.

Rob Relyea, XD011, Windows Presentation Foundation for Developers – (Part 1 of 2), Wednesday 10-11:15, Lando 4204 (Right before mine, come to both.)
Kevin Gjerstad, BDM03, The Art, Science, and Business of Killer Content Experiences, Tuesday 8:30-9:45AM, Delfino 4101A
Mike Harsh, XD001, Deep Dive on Silverlight Media Integration, Tuesday 2:15-3:30, Lando 4201
Robby Ingebretsen, XB003, "ZAP!, WHAM!, KAPOW!": Windows Presentation Foundation and the Next Generation of Online Comic Book Reading, Monday 3-4:15 PM, Delfino 4005

For those attending MIX, my Sandbox page is mixer1029.mixsandbox.com.

See ya'll in Vegas!

New URL, Same Great Taste!

2007-04-08T16:30:00.001Z

Hello WPF fans, glad you found your way to my new blog.

I'm trying to consolidate all of my web-based shenanigans.

MSDN blogs has treated me well for 4 years. Check out the old URL for my previous wit-and-wisdom. It should stick around for a while.

Here's to new beginnings!

(I'm sure I'll get fewer questions about Okoboji. Never be afraid to ask, though.)