Preston L. Bannister { random memes }

The rather twisted semantics of this CATO article remind me of Alice’s Humpty-Dumpty.

“When I use a word,” Humpty Dumpty said, in rather a scornful tone, “it means just what I choose it to mean — neither more nor less.”

I have a lot of sympathy for CATO’s philosophical bent. Occasionally they jump track and go crashing into the trees. Maybe this is simply their way of paying the bills, and making their sponsors happy?

What exactly is “social capital”?

Cato-at-liberty » Undermining America’s Social Capital with Redistribution
America’s lowest-earning one-fifth of households received roughly $8.21 in government spending for each dollar of taxes paid in 2004. Households with middle-incomes received $1.30 per tax dollar, and America’s highest-earning households received $0.41. Government spending targeted at the lowest-earning 60 percent of U.S. households is larger than what they paid in federal, state and local taxes. In 2004, between $1.03 trillion and $1.53 trillion was redistributed downward from the two highest income quintiles to the three lowest income quintiles through government taxes and spending policy.

I am having trouble with the use of “received” here. On one side, each of us benefits – to a greater or lesser degree – from living in this country. On the other side, the country incurs expenses that must be paid. Is the benefit derived independent of income, or proportional to income? Probably a bit of both. This duality leaves lots of room to “spin” the numbers so you can make an argument (whatever the argument).

The use of “redistributed” also seems rather dubious. Money is disappearing into the black hole of government spending. Money is not transferred between households (with minor exceptions).

This huge shift of resources punishes those who produce and rewards those who do not. This hurts economic performance by distorting incentives.

First, there is not an exact map between “those who produce” and income levels. Income level measures how much you are rewarded, not how much you produce. Do you really believe income is exactly proportional to how much you “produce”? Second, the above statement seems to imply the most-rewarded folk will be discouraged from producing. Is there any evidence of this? So what would they do, stop producing? Leave the country? Commit suicide? Somehow this seems unlikely.

An even more interesting measure is your “reward” after taxes, cost of living, kids, retirement savings (etc.) … another topic, though closely related.

From: acmhelp@hq.acm.org
To: preston@bannister.us
Subject: An Invitation to Join ACM

Dear Preston Lee Bannister,

Thank you for registering with the ACM Digital Library, ACM's vast collection
of more than 40 publications and archives, representing over 1.4 million
pages of text.

Since that 1.4 million pages is in a ghetto, when searching I would end up launching two searches, one via Google over the general web, and the second within ACM’s little universe. That assumes the ACM has a decent search engine. Sounds like a pain.

Now that you've had a chance to experience this valuable resource, we'd like
to introduce you to some of the additional benefits available to ACM members,
including:

Signing up gave access to nothing, so I have not “experienced” anything.

- Free, unlimited online access to 450 courses and 395 books in the
ACM Professional Development Centre

I do buy a fair number of books, but none have said “ACM” anywhere.

- Full year subscriptions to "Communications of the ACM," "MemberNet,"
"TechNews" and "CareerNews"
- Full access to the Guide to Computing Literature and the ACM Career Centre
and Job Board 

This is better than similar resources on the web, how?

- A free email forwarding address

This would be better than preston@bannister.us in what way?

- A special first year introductory rate and a free gift for professionals

(Feel a bit funny about this, as I was a member for about 10 years, ending about 15 years ago.)

- Special discounted member rates and a free gift for students
- And much more!

Learn more about ACM membership, and join today at:  

http://campus.acm.org/public/qjstuwithbook/joinacm2.cfm?client_no=%27%2A%5CW%2CP%3CW%273%20%20%20%0A

(You may need to cut and paste the entire link above into your browser. If the URL wraps,
be sure to copy it completely, leaving no blank spaces.)

ACM's mission is to advance both the discipline and profession of computing.
For more than 50 years, ACM has been widely recognized as the premier organization
for computing professionals, and today, ACM helps over 80,000 professional and
student members worldwide gain access to the information they need and want.

Twenty years ago ACM membership fit the description above, and was indeed valuable. Now … not so much. Kind of sad, really.

Join now to take advantage of this very special offer!

Sincerely,

ACM Member Services
acmhelp@acm.org

http://www.acm.org

P.S. All ACM members must subscribe to the purposes of ACM. You can access
the ACM Code of Ethics at: http://www.acm.org/serving. ACM will never sell
or rent your email address.

Client No.: 1923043
Email on record:  preston@bannister.us

Probably not ….

There is one mistake I have seen repeated over and over (and over…) in applications that work across the network – from the 1980’s up through the present. The symptom is an application that works fine in testing, but performs very poorly when deployed. The cause is developers who fail to use the network efficiently.

The example I first saw was when at FileNet in the 1980’s, and we hooked up a client workstation over a 56Kb/s connection. The drop in performance was much greater than the difference in data rate with the 10Mb/s local area network. Accounting for the difference was initially a puzzle.

Networks have both overhead and latency. Latency is time it takes for a message to travel across the network. When the test server is on the same wire as the test client – the usual case in development – latency is quite small, can be and (by mistake) frequently is ignored by developers. At this stage of development an application that passes many messages across the network can perform well. Developers tend to a design nice uniform network API – much like the interface to a local library. With an API of this sort, client startup might take hundreds or thousands of messages sent across the network.

With a simple PING test, I see ~0.01ms for a round-trip to my local server, ~10ms to my ISP’s local mail server, and ~100ms to most major sites on the web. The latency to cross the web is about a thousand times the latency on the local network. The latency to cross my ISP’s intranet is about a hundred times the local latency.

Note that latency is essentially unaffected by the speed of your network connection or your servers. If latency is a problem, acquiring a faster network is unlikely to help. A faster network connection is really better described as a higher capacity network, as the you can send more bits per second, but the bits don’t cross the network any faster.

At FileNet the 56Kb/s link went off-site, and had latency not very different from a web connection today.

The problem comes when the application is deployed, and the server is no longer local. A hundred calls across the network cost the application perhaps 1ms of latency in developer testing (seldom a concern). A hundred calls across the web could easy add 10 seconds, and make an application noticably slow. On the local network you could make hundreds or even thousands of calls without noticing a drop in performance. Move the same application to the web (or a company WAN) and performance becomes painfully slow. Once the problem hits you in the face (1980’s in my case), the answer should be obvious. For optimal performance you want one call across the network for one user action. Program startup? One network call. User clicks a button? One network call.

You must not design a network API the same way you would design a local library.

Which leads us to REST. I very much like the idea of using HTTP without any unnecessary added abstractions. I like the idea of stateless interaction. When writing client/server applications it became clear that using stateful connections were as much a problem as an aid – even in the 1980’s. What I find disturbing is the repeated reference to a uniform interface, and reference to using GET / PUT / POST / DELETE methods.

Put simply, a REST API should be asymmetric. For minimal latency, the oft-used GET calls should return a collection of objects. Since changes usually cause side-effects, the oft-used POST calls should return a collection of objects. Latency matters. To avoid the risk of new (and not so new) programmers repeating old mistakes, we need to offer a model that accounts for latency. A good network API should by design aim for one request/response per user action.

Note also that there is no point in trying to re-use the HTTP method (i.e. GET, PUT, POST, DELETE, etc.) as a verb, since most applications need a somewhat greater vocabulary. Shoehorning your application into the HTTP verbs is probably a bad idea. Better to stick to GET for read access, and use POST for changes. Note that using fewer messages to minimize latency also helps an application to scale. The OS and web server overhead for handling requests is pretty much fixed per message. Fewer messages mean less overhead, and more capacity available to your application.

If you take latency into account, then the REST model becomes:

• GET collection of nouns
  returns response: collection of objects.
• POST collection of actions (where an action is a verb and a collection of nouns)
  returns response: collection of objects.

The REST model is a step forward, and better with an emphasis on asymmetry and collections.

Another slightly dizzy story from CATO.

Respecting Property Rights
This dramatic photo appears on the front page of today’s New York Times.

Chinese authorities are respecting the legal rights of a landowner who does not wish to sell her parcel. Maybe this incident will have a Sputnik-like effect on American policymakers: “Hey, the commies are getting ahead of us on property rights! Let’s reverse the Kelo ruling and stop eminent domain abuse!”

The original article paints a slightly different picture. Seems the property owner’s rights are going to be “respected” in a rather odd way.

Homeowner Stares Down Wreckers, at Least for a While
[...] a house perched atop a tall, thimble-shaped piece of land like Mont-Saint-Michel in northern France, in the middle of a vast excavation.
[...] in a way that is common in China whenever an event begins to take on hints of political overtones, the story virtually disappeared from the news media after the government, bloggers here said, decreed that the subject was suddenly out of bounds.
[...] “For over two years they haven’t allowed me access to my property,” said Ms. Wu, [...]

“If it were an ordinary person they would have hired thugs and beat her up,” murmured a woman dressed in a green sweater who was drawn by the throng. “Ordinary people don’t dare fight with the developers. They’re too strong.”

Ms. Wu will in all likelihood lose her battle. Indeed, developers recently filed administrative motions to allow them to demolish her lonely building. Certainly the local authorities are eager to see the last of her.

“During the process of demolition, 280 households were all satisfied with their compensation and moved,” said Ren Zhongping, a city housing official. “Wu was the only one we had to dismantle forcibly.”

Note the past tense on the quote from the city official. Not sure that I would class this as respect.

Oh boy, has a lot ever changed since I wrote Sun was cool. In the time between, Sun has done some very cool stuff.

Moving the Sparc family out of the hot-rod-single-CPU (i.e. PC) race into a high-net-throughput, power-efficient multi-core design is cool (no pun intended). Makes perfect sense. Far more daring than I then expected from Sun. Buying CPUs for “hot rod” applications from AMD (and now Intel) makes perfect sense, and covers the case where customers need x86 compatibility.

Maybe because my first job out of college involved writing hard disk drives and file system code, but it has always seemed to me that we were not getting all the performance possible out of disk storage. Seemed that at the intersection of RAID, journaling, and copy-on-write you could do something really interesting. Design is a bit tricky, and requires serious thought. (One of those “interesting” problems I thought would be fun to work on, given the chance.) Someone finally did the work in ZFS. ZFS came from Sun (not Microsoft, not IBM, or anyone else).

Even more audacious is Sun’s Project Blackbox. The notion of engineering the equivalent of a data center in standard shipping container is brilliant. Today most “data-centers” are effectively built one-at-a-time in the field. Getting a data center up and running is expensive and risky. Each data center is probably a unique combination of power, cooling, networks, and computers. Unique combinations are going to have unique problems. Problems mean going back to the vendors – often with many rounds of troubleshooting. Many iterations mean time and money wasted.

When Introducing Project Blackbox Jonathan touched on how designing the “datacenter” as an integrated unit pays big benefits. By engineering the whole package, Sun can design and load up exactly the right power, cooling and networks for the computers needed. By assembling and testing the entire package at Sun, the customer can expect to save ($$) a huge whack of the usual “integration” time. Add to this a big box full of disks that with ZFS you can let fail in place. (Ever buy a replacement disk for a four year old RAID? If so fail-in-place should make sense to you.) The benefits multiply, rather than add.

I thought the benefits of this all should be pretty obvious. Searching the web I see there are more than a few folk who still do not get it. No, the Blackbox is not just another mobile center. The mobile part is useful, but almost incidental. The advantage is the fact that you get a fully integrated, tested, and functional datacenter in a box. By assembling the entire datacenter as a unit, Sun can save customers time and money, while still turning a decent profit. This is a good deal all around.

Would you consider buying a car or television as parts, and assembling it yourself? In the usual case, no, as the do-it-yourself approach is going to cost you both time and money, and in most cases, there is no advantage.

Sure, other folk have done datacenter-in-a-box stunts before – but they were nothing more than stunts. You need all the pieces before this becomes an integrated whole, and an effective offering. Many of the pieces require deep expertise on the part of the company behind the product. Essential bits needed include …

• You need an operating system throughly suited for large-scale lights-out managed-system operation. Sun has Solaris.
• You want hardware that performs well at a reasonable price. You need hardware designed to work well with the operating system (no corners cut). Sun designs and builds some very nicely done hardware.
• You need cost effective and reliable storage. With ZFS the Sun folk can take full advantage of mass-market hard disks. ZFS enables a cost/performance/reliability combination no one else can match. Sun’s box-full-of-disks “Thumper” product without ZFS would be just a stunt. With ZFS you have something very interesting.
• You need broad expertise from the vendor. As a customer, this means you have one place to go for a resolution.

Big companies tend to get, well … beige. Perhaps Sun was always colorful on the inside, but on the outside … for a while, not so much. Sun has suddenly become colorful – in a creative and insightful sense. Very cool.

This following is pure/idle/random speculation, and rather old from my personal point of view.

Many years ago ran across the “grandfather paradox” in science fiction. The stories always seemed to revolve around an effectively immutable past. At the time, this struck me as wrong – given time-travel (a rather big given) the past cannot be immutable. At the same time I expected each individual’s memory of their own personal past to remain unchanged. Starting from the (apparent) paradox, this lead to a sort of thought-experiment.

Assume an infinite universe. In an infinite universe, all combinations of atom, molecules, planets, galaxies … must occur. Nature seems to tend to elegance, so identical combinations should (perhaps) exist once, and this continuum of combinations must be somehow adjacent, along a dimension of sorts. Identical combinations collapse to a singular instance – something like a standing wave. This means every possible world exists in a continuum along some dimension. Every possible past and every possible future exist in this continuum. Many possible pasts (an infinite number – or nearly so) could lead to a single future. A single past could – based on a single quantum fluctuation – could lead to more than one future (though in most cases not).

Assuming this model, the “grandfather paradox” cannot exist. By traveling into and changing the past puts you onto a one of the infinite different paths to the future. You cannot change the past from which you came, but you can change another (though “change” is the wrong word).

Well fine – this was an entertaining bit of speculation derived from reading science fiction as a teenager in the 1970’s. Did not expect this to have any measurable impact on “reality”. Did not expect this to be in any way measurable.

But what if it was measurable? What could we measure if this were in any way an accurate model?

Before I thought the model was absurdly unmeasurable – after all we could have two world-paths differing only by the single random quantum fluctuation of a single atom – the combinations might in some sense finite, but still for all practical purpose infinite. Many pasts might collapse to a single future, and random quantum fluctuation light-years away will almost never impact the combined weave of probabilities that make up any one present. Assuming the tendency to elegance in the universe – perhaps our present in the sum of many (a nearly infinite number) of pasts that computed to the same present.

What if this were measurable?

As we look further out into the universe, we are looking out to regions that have no impact on our present or future. Might we expect to see all possible pasts – the further out we look – that compute to our single (as we perceive) future? Would the universe look “fuzzy” the further we look? Would we see all possible pasts? Could we measure when parts of our present came from a differing pasts?

Could this collapse of combinations reach into the macroscopic levels? Could you and I remember the past differently, as we are from different threads of experience through the weave of possibilities? As long as our differing memory has no effect on the future, could these threads of experience cross between differing “realities”?

Oddly enough, starting with the premise of an infinite universe, and adding the apparent elegance of nature, you end up with a weave of near-infinite (though finite) set of possible pasts leading to a near-infinite (though finite) set of futures. Is it possible this is measurable, as we peer further out into the universe?

Idle speculation…

HTML and the DOM as currently defined are quite a hash. Given the history of web browsers, this is understandable, if unfortunate. Browser makers are not the only culprits, as the W3C HTML standards are … a little funky.

Sounds like the W3C HTML working group is opening up to more general participation. The charter seems to have a bit more of a pragmatic flavor. This could be a good thing. Followed the steps for joining (as an individual).

Possible goals for reinventing HTML:

Do no harm (or at least as little as possible)

This means HTML5 documents should render in existing mainstream browsers (IE6/7, Firefox, Safari) as much as is practical.

Allow for extensibility

HTML in combination with Javascript is a programming platform. Each site is an application. The generated HTML is in effect a dialect, potentially with node and attribute names meaningful only to that site’s application. Draw on Lisp/Scheme as a model (not for specifics).

Provide a clear/simple/minimal model

HTML and the DOM are at present quite a hash. There should be one clear model for a programmer to follow. This will mean removing some of the left-over debris. When in doubt, leave it out.

Digesting HTML, CSS, the DOM, Javascript, and some of the (many) variations tried in building web applications – took a while. With any new area I need to grok current state before I feel comfortable working. The end result is a personal internal model of how things work and could or should be used. In the end I believe the model for HTML programming could and should be both much simpler and more flexible. As a model I am back to drawing on a approach probably very familiar to Lisp/Scheme programmers.

An HTML document is simply a tree of typed nodes. With each node there are per-node attributes, and per-node-type common properties. Default behaviors and style are associated with each node type – some of which can be overridden (with varying degrees of success).

As a programmer, I can (to some degree) re-invent the presentation and behavior of existing HTML nodes to meet the needs of my application … with lots of little exceptions. I would like to simplify the model by removing the exceptions. As a programmer, I could achieve the greatest clarity of expression by adding named attributes and nodes as needed for my application. An HTML page is a data structure, very much like a Lisp S-expression – and I think there is a benefit in treating it as such, and in making this treatment explicit.

O’Reilly — In Memory of Frank Willison
On The End of the World, and Yes, It’s Nigh

“Partway through Elliotte Rusty Harold’s talk about namespaces, I realized where this relentless drive toward abstraction was taking us. Every new level of abstraction draws the computer-based world closer to the concepts we talk about in the real world. We’ve moved from waves to bits to data to information to infosets to application objects. As this process continues, some ambitious Comp Sci graduate student will realize that somebody already created the tree structure mapping the highest level of reality. That person was, of course, G. W. F. Hegel. Hegel’s dialectic led him to create a map of reality that, at the top of the tree structure, divided everything into either the material or the spiritual realm. That dichotomy was resolved in God, and, my friends, that’s about as far as you can go.

“That ambitious Comp Sci grad student, eager to get his Ph.D. and begin making real money, will create The Two Final Infosets: MatterML and SpiritML. Then, late one night, as rain falls in torrents and lightning flashes outside his laboratory windows, he’ll run XSLT to transform the material world to the spiritual world. We’ll be gone. The last material object on earth will be that graduate student’s open copy of XML in a Nutshell. It makes an editor in chief proud, in a perverse kind of way.”

Something for the Java folk too fond of piling on abstractions…