dæmonology

Jackie Speier Disappoints Me

nobody@vox.com(j h woodyatt) — Sat, 29 Aug 2009 13:24:46 -0700

My member of the U.S. House of Representatives is Jackie Speier (D-San Mateo). I have just returned from her Families and Health Care Forum Event at Burton Park in San Carlos, which was attended by a few hundred constituents of which only a handful were unruly and disorderly protestors. I have some news to report about what her press director told me personally at the meeting when I could not address my question directly to the congresswoman.

Before I tell you what I heard, and why I'm disappointed, let me first be fair to her. I should note the following points:

She supports HR. 3200, the compromised but still acceptable House reform package with the gutless public option and the slow phase-in.
She also supports HR. 676, the Kucinich amendment that would allow California and other states a way to implement single-payer systems.
She is one of 60 members who signed the Pelosi Letter, which declares that the Waxman deal with the Blue Dog Democrats on the Energy and Commerce Committee that would gut the House bill of the public option and many of the other important provisions to control health care administrative costs.

These are all good positions. I'm glad she's taken them. So, why am I disappointed?

Because it's clear to me that she's insincere. She's all in favor of real health insurance reform, but not up to the point where she has to take a real stand where it counts. How will she vote when the bill comes out of conference with the Senate, and it doesn't have a public option for controlling costs? When it doesn't have subsidies for low income families? When it has individual mandates for private health insurance with criminal penalties for compliance, but nothing to make private insurance either affordable or universal? How will she vote then?

I put that question directly to her press director, Mike Larsen, and I made it clear that I want an unequivocal public declaration, now, not later when the outcome of the conference committee is a fait accompli. He responded with two clear statements of the congresswoman's position:

She absolutely will not take the Firedoglake pledge to vote NO if the final bill does not contain a real public option.
If the final bill fails to comprise a public option or any of the other improvements that her public statements say she supports, but President Obama promises to sign it, then she will vote YES on the final bill.

Congresswoman Jackie Speier gives a decent slide deck, but I think we can safely say she isn't committed to real reform. When the final bill comes, and it turns out to be a wet sloppy kiss from Senator Grassley to the greedy and rapacious special interests in the health insurance industry, she is planning to sell out her constituents' health and families, while smiling and pretending that she did everything she could to prevent it. It will be a dirty lie, and I plan to remind all my neighbors and friends in her district of that tawdry fact every chance I get.

Yes, I am extremely disappointed. I gave the congresswoman money for her re-election in 2010 before I found out about this betrayal. I want my money back.

Read and post comments | Send to a friend

Persistent Union-Find Data Structure

nobody@vox.com(j h woodyatt) — Thu, 02 Jul 2009 12:05:23 -0700

In my previous post, I whined about how it didn't seem to me that a pure-functional union-find data structure should be so hard to make as computationally efficient as the well-known imperative algorithms. After some wonkulation on the subject, I convinced myself that— yes, bunky, it's true— functional purity really does cost extra, and sometimes it costs enough that it's worth sacrificing purity for efficiency.

There are a lot of techniques for hiding imperative code behind functional interfaces, and I know them fairly well at this point, so I thought I would try my hand at designing an [impure] persistent union-find data structure with optimal complexity characteristics.

I'm not by any count the first person to try to do this. Sylvain Filliâtre and Jean-Christophe Conchon did it a few years ago, and they were thorough enough to provide a formal proof in Coq alongside it. They did a great job, but there are some nitpicky things about their code that I wish were done differently.

FIND returns the representative element of the set, and I'd rather the code allowed for the representative of the equivalence class to be of a type different than the set elements. This is because I'm planning to use the data structure in a constraint solver for type inference.
Their code requires the elements to be integers suitable for indexing persistent arrays. This is unacceptable for me. I want an algorithm suitable for any totally ordered set of elements.

So, I wrote my own. Instead of using persistent arrays, it uses the persistent set and priority queue data structures from the Cf module in my OCaml Network Application Environment library. Here's the [untested] code:

module type T = sig
   type k and +'a q and +'a t

   val nil: 'a t
   val start: k -> 'a -> 'a t
   val find: k -> 'a t -> 'a q option
   val extract: 'a q -> 'a
   val disjoint: 'a t -> 'a t -> 'a t
   val union: 'a q -> 'a q -> 'a t
end

module Create(K: Cf_ordered.Total_T) : (T with type k = K.t) = struct
   module U = Cf_rbtree.Set(K)
   module H = Cf_sbheap.PQueue(Cf_ordered.Int_order)

   type k = K.t

   type 'a q = Q of U.t * int * 'a * 'a t
   and 'a t = T of int * (k -> 'a q option)

   let void_ _ = None
   let nil = T (0, void_)

   let start k v =
   let q = Some (Q (U.singleton k, 1, v, nil)) in
   let f k' = if K.compare k k' <> 0 then None else q in
   T (1, f)

   let find k (T (_, f)) = f k
   let extract (Q (_, _, v, _)) = v

   type 'a compressor = {
   mutable z: int;
   mutable h: 'a q H.t;
   mutable u: U.t;
   mutable f: k -> 'a q option;
   }

   let compress_ =
   let rec loop c k h =
   if U.member k c.u then
   None
   else
   match H.pop h with
   | Some (hd, tl) ->
   let _, q = hd in
   let Q (u, _, _, _) = q in
   if U.member k u then Some q else loop c k tl
   | None ->
   if c.z = 0 then
   None
   else
   match c.f k with
   | None ->
   c.u <- U.put k c.u;
   None
   | Some q as q1 ->
   let Q (_, n, _, _) = q in
   c.h <- H.put (n, q) c.h;
   let z = c.z - n in
   assert (z >= 0);
   c.z <- z;
   if z == 0 then begin
   c.f <- void_;
   c.u <- U.nil
   end;
   q1
   in
   fun c k ->
   loop c k c.h

   let disjoint a b =
   if a == b then
   a
   else begin
   let T (na, fa) = a and T (nb, fb) = b in
   let n = na + nb in
   let f =
   if n > 1 then begin
   let f1, f2 = if na > nb then fa, fb else fb, fa in
   fun k -> match f1 k with Some _ as q -> q | None -> f2 k
   end
   else if n > 0 then begin
   if na > 0 then fa else fb
   end
   else
   void_
   in
   let c = { z = n; h = H.nil; u = U.nil; f = f } in
   T (na + nb, compress_ c)
   end

   let union a b =
   let Q (ua, na, v, ta) = a and Q (ub, nb, _, tb) = b in
   if ta == tb && ua == ub then
   ta
   else begin
   let qn = na + nb in
   let T (n, f) as t = disjoint ta tb in
   let z = n - qn in
   assert (z >= 0);
   let rec q = Q (U.union ua ub, qn, v, t)
   and c = lazy { z = n; h = H.put (n, q) H.nil; u = U.nil; f = f } in
   let c = Lazy.force c in
   T (n, compress_ c)
   end
end

As I mentioned above, this is totally untested code. If you use it without testing the hell out of it yourself, then it will be your own damned fault if it bites your leg off. I'll be getting around to testing it someday soon, and if it works well, then I'll be adding it to the next release of the Cf library. No promises on when.

How does this code work? It's easy, really.

In the module signature of the functor, type k is the set element type ('k' is for 'key' here), 'a q is the type of equivalence classes where each key in the class is equivalent to a value of type 'a, and 'a t is the type of disjoint sets partitioned by equivalence class.

The empty disjoint set is nil. It contains no equivalence classes.

To create a new disjoint set with a single key k and its representative value v, use start k v. Use find k t to search the disjoint set t for an equivalence class containing key k. Use extract q to extract the representative value from the equivalence class q. The find function has a variable cost discussed below, but start and extract both have constant cost.

It is an invariant that the optional value q returned for positive results of a search with find k t is always the same for every equivalent key k in the disjoint set t. Each q returned by find k t contains a reference to t to facilitate path compression, which is discussed below. The cost of find is a the cost of searching a memorized queue of previously found equivalence classes, prioritized by size from largest to smallest, plus the cost of searching any predecessors for remaining equivalence classes, plus the cost when there are still predecessors of searching a cache of negative results.

To combine two existing disjoint sets a and b into a new disjoint set comprising equivalence classes from each, use disjoint a b . If a and b are identical values, then this is a trivial operation. Otherwise, a fresh path compressor is used to memorize equivalence classes when searching the two predecessors. Applying disjoint to a pair of predecessors that contain overlapping equivalence classes is not an error, but the results might seem arbitrary: the predecessors are only searched by find k t when no previous search of t has returned an equivalence class containing k; when the predecessors are searched, the larger predecessor p1 is searched first with find k p1, then the smaller predecessor p2 is searched with find k p2. The first positive result is memorized by the path compressor. A pair of negative results is also memorized. Once all the predecessor equivalence classes are memorized, the associated search function in the compressor is destroyed, which allows the predecessors to be collected.

Finally, use union a b to create a new disjoint set comprising a fresh path compressor constructed to search the predecessors encapsulated in a and b, and with memory pre-initialized to the equivalence class produced by merging the key sets and choosing the value represented by a as representative of the new class. As discussed above with regard to the likewise disjunct function, if a and b were found in overlapping disjoint sets, then the choice of which equivalence classes are memorized in the path compressor is arbitrary.

Worth noting: it's not clear to me that the negative cache is worth it. If you always search for keys that you know are present in the disjoint set, then the cache won't hurt much. However, negative results from searches in uncompressed sets are costly. A negative result can only be obtained by iteratively descending the predecessor graph to make sure none of them have an equivalence class that needs to be memorized. I'm not sure there's much to be gained by caching such negative results until the path compressor determines that the equivalence classes in the predecessors are exhausted. That will certainly be one of the things I will set about to testing when I next get time for this project.

Read and post comments | Send to a friend

Pure Functional Disjoint Set Union-Find...

nobody@vox.com(j h woodyatt) — Wed, 01 Jul 2009 11:26:26 -0700

...is apparently not terribly efficient. This makes me sad. The problem doesn't seem like it should be as hard as it appears to be. This makes me more sad.

I've been doing a lot of pure functional programming. I wonder if I can discover a pure-functional union-find data structure with computational complexity similar to Tarjan's optimal imperative algorithm. Grmf.

Update: okay, I think I've convinced myself that purism really is a lost cause on this subject. How-some-ever, I've now written a persistent [impure] functional union-find data structure that I believe has optimal computational complexity. I'll post a follow-up.

Read and post comments | Send to a friend

I Am Officially Weirded Out

nobody@vox.com(j h woodyatt) — Tue, 26 May 2009 20:17:25 -0700

Apparently, the ghost of Jon Postel is leading a pack of superheroes determined to defend the Internet from Fear Uncertainty and Doubt. Promote The Internet Way with Team ARIN!

Welcome to the world of Team ARIN! We hope you find these publications educational and entertaining. Team ARIN is a fictionalized view of the American Registry for Internet Numbers (ARIN), its processes, and the whole concept of Internet governance. Though our heroes are fictional, the issues they face are very real.

Team ARIN is a group of superheroes that represent four of the principles by which the Internet is operated and governed...

Read and post comments | Send to a friend

A Fine Rant For Colleagues To Read

nobody@vox.com(j h woodyatt) — Tue, 28 Apr 2009 16:25:52 -0700

The Problem With Software Transactional Memory: Your Languages Still Suck.

He's right, too. Parallelism is a bitch. Anyone who has ever had this experience...

Classic threads and locks (or threads and synchronized, for you Java programmers) lead to the worst sort of Heisenbugs. True story: I once had to trace down a race condition that, doing several thousand tests per second, only manifested itself once every four days on average. The vast majority of the time it’d work just fine- the rate of failure was small enough it had escaped testing (think about it- you’ve been running the same test, thousands of times a second, for three days, and it hasn’t failed yet- when do you declare that it looks like the test is working?), but it was common enough that it was causing our customer to lock up about once a week, so it had to get fixed. Oh, and threads and locks aren’t compositional- you can’t take two hunks of code which are individually correct, and combine them to form one large, correct, piece of code. But hey, it’s not like code reuse is that important to programmers, is it?

...doesn't need to be told how symmetric multiprocessing with traditional threads and locks is the shadow of death, the mindkiller, a road of bones down which nothing but torment and pain will you ever find.

Read and post comments | Send to a friend

Apparently...

nobody@vox.com(j h woodyatt) — Wed, 18 Mar 2009 16:53:53 -0700

I am:

Kurt Vonnegut

For years, this unique creator of absurd and haunting tales denied that he had anything to do with science fiction.

Which science fiction writer are you?

For the record, yes I do continue to insist that I'm a writer of fantasy, not science-fiction. So, perhaps this comparison is not entirely full of bogosity.

Read and post comments | Send to a friend

An Abstract Machine

nobody@vox.com(j h woodyatt) — Thu, 12 Mar 2009 21:16:04 -0700

I seem to have one. Here's the OCaml signature. The module file is all of 250 lines at this point, but I expect to define a lot of built-in processes for the preamble. That will bloat out the module file.

type 'a t
module Op: sig
val ( >>= ): 'a t -> ('a -> 'b t) -> 'b t
end
val return: 'a -> 'a t
val eval: unit t -> unit
type n
type repeat = Once | Always
val nil: unit t
val start: unit t -> unit t
val lambda: n t
val nu: n t
val fusion: n -> repeat -> n list -> unit t -> unit t
val v_void: n
val v_true: n
val v_false: n
val if_then_else: n -> unit t -> unit t -> unit t
type dio = D_in | D_out
val def: dio list -> (n array -> unit t) -> n t
val preamble: n Name.Map.t t

Basically, the abstract machine is a monad. I'll compile programs into an abstract syntax tree, then when the tree is pruned until it conforms to all the syntax and semantics invariants, I'll visit the nodes to compose a monad value. I'll execute the program by evaluating the monad. To say that it will not be fast is an understatement of Brobdingagian proportions. It will be simulating concurrency in a single thread of control, which will seem like a wide miss of the whole point. It will, however, allow me to experiment with higher-level language syntax and semantics for a while before I hit the next wall, where I expect I will need to write a byte code interpreter in C with POSIX threads to make further progress.

Read and post comments | Send to a friend

Hey, Ecuador!

nobody@vox.com(j h woodyatt) — Tue, 10 Mar 2009 10:15:20 -0700

I want my coins back.

Read and post comments | Send to a friend

Toward An Abstract Syntax

nobody@vox.com(j h woodyatt) — Mon, 09 Mar 2009 18:43:12 -0700

I continue to noodle around with an abstract syntax for types in my internal language. (Sigh. This is taking forever.) Here's what I'm looking at now:

τ ::= α | ν⟨σ⟩ | λ(σ)

σ ::= ∀δ,σ | ∃α,σ | τ,σ | ϵ

δ ::= α | α = τ | α > τ

Explanation. A type (τ) is either a named type variable (α), or a channel type of shape (σ) with either λ- or ν- binding. A shape (σ) is a list of universal quantifications, existential quantifications and type declarations terminated by the shape terminator code (ϵ), i.e. a channel that carries no types or values has type ϵ. The universal quantification is enriched with flexible (>) and rigid (=) constraints.

Some syntactic sugar is useful. The trailing ϵ in a shape can be elided from the bracketed expression in a λ- or ν- type expression, i.e. ν⟨α,β,ε⟩ can be written ν⟨α,β⟩. If the shape of a channel type expression has only one term before the ε, then the brackets/parentheses may be elided, i.e. λ(α,ε) can be written λα.

I'm still going back and forth with myself over where the λ's and ν's belong.

Read and post comments | Send to a friend

Monads In The π-Calculus

nobody@vox.com(j h woodyatt) — Mon, 09 Mar 2009 09:10:44 -0700

While I was in the shower this morning, it occurred to me that I should make a note for myself about how monads work in the polyadic D-fusion calculus.

The type construction is simply a channel (να) for sending a value of the underlying type.
The unit function is a channel (να λ(λ(να))) for sending a value of the underlying type and receiving a responsive channel that carries the resulting monadic value.
The binding operation is a channel (να ν(να λ(λ(νβ)))) λ(λ(νβ))) for sending two values, 1) a monadic value of type α and 2) a channel for sending a value of the underlying type α and receiving a responsive channel that carries the resulting value of monadic type β; the binding operation channel also permits receiving a responsive channel that carries the resulting value of monadic type β.

Easy as cake.

Note: the process defined according to the type above for the binding operation always starts when both inputs are available. There are two possible optimizations here: one where the process begins immediately when the value of monadic type α becomes available and one that begins immediately when the bound channel becomes available. The description of these types is left as an exercise.

Update: I made some consistency errors in the first revision of this post, so I went back and edited it to correct errors.

Read and post comments | Send to a friend