Wondering if there were more of these, I recently asked readers for their “tricks of the trade,” and was amazed by the response. It seems every profession is rich with clever little occupational secrets. Here are some of the best of what I received.

Actor

Attorney

Auto Mechanic

Balloon-Twister

Botanist

If you know the length of each of your fingers as well as your handbreadth in centimeters, you can measure the leaves of most plants without having to pull the ruler out of your backpack.

And when doing botanical work in South America, steer clear of the monkeys: They will throw sticks at you with surprising accuracy.

Butcher

• kool, toh lrig
• cuf ecaf
• on erom feeb/gip/bmal
• traf
• toor
• doog tsub
• tish
• doog esra
• gaf

Cardboard Box Flattener

Cartographer

Clarinetist

Desktop Support

Forester

The senior forester also will be the one either driving the truck or sitting in the middle seat; it’s the guy who’s riding “shotgun” who has to get out to open and close every gate they encounter.

Graphic Designer

Jeweler

Also, because most stones are pretty irregular (being stones and all), fill the base of the setting with sawdust so the stone will set evenly.

Juggler

Landscape Architect

Lounge Pianist

Massage Therapist

Mechanic

Newspaper Headline Writer

Nurse

Paramedic

Photographer

Piano Salesman

Proofreader

Software Tester

Street Performer

Technical Support

Waitress

Wedding Coordinator

The sci-fi legends who shaped today's tech

Posted on 20 Nov 2009 at 16:17

Science fiction has long inspired real-world technology, but have the authors of sci-fi stories finally run out of steam? Stuart Andrews investigates

From the earliest days of Jules Verne and HG Wells, science fiction and technology have enjoyed a mutually beneficial relationship. Sci-fi stories and novels expressed man’s desire to conquer space, find new worlds or explore the ocean depths, and while man would probably have landed on the moon or launched deep-sea expeditions without them, these tales inspired those who made such giant leaps.

In turn, real-world technology has inspired the science-fiction writer. After all, it’s science fiction that charts what happens when humanity meets high technology, asking what will happen, where it will take us, and what we’ll find when we get there. This is as true of computer technology as it was of the space race. Perhaps, even more so.

The geek and hacker cultures that have powered so much of the PC and internet revolution are hugely sci-fi literate. Writers and experts have even crossed paths; the academics and software engineers becoming sci-fi writers, the writers earning a name as futurologists.

In this feature, we’ll explore how science fiction has motivated trends and products in computing, and catch a glimpse of where this relationship might take us in the future.

Visions of the future

Does sci-fi really have that great an impact on the technology that emerges from the labs of the world’s biggest technology companies? Labs that are so well funded (Microsoft alone spent $8 billion on research last year) that they can afford to scoop up the brightest talent emerging from MIT and beyond? Indeed it does, according to Bruce Hillsberg, director of storage systems at IBM Research in Almaden. For him, the value of science fiction is that it “paints visions of the future that cause people to think about possibilities beyond what is possible today”.

Sci-fi can consciously or unconsciously help authors think outside the box

Hillsberg believes the fact so many hi-tech visionaries are sci-fi fans, tied to fiction’s power to stimulate creative thought processes, means that an interest in the genre can lead to real breakthroughs. “I don’t believe sci-fi necessarily sets the agenda for researchers,” said Hillsberg. “That is, I don’t think most researchers try to invent what they read about or see in movies. Rather, they try to move science or technology forward, and sci-fi can consciously or unconsciously help them think outside the box.”

History bears out his theory. Do a little digging and you’ll be surprised to find how many big names in the computing world are sci-fi fans: Apple’s Steve Wozniak, Netscape’s Marc Andreessen, Tim Berners-Lee, Google’s Sergey Brin and the GNU Linux creator Richard Stallman, to name only a few of the tech elite. Microsoft co-founder Paul Allen has even helped fund a museum of science fiction in Seattle.

To Hal and back

It wasn’t long into the history of computing that the sci-fi greats began to see technology’s potential. During the 1950s, Isaac Asimov wrote a sequence of stories featuring Multivac, a huge, artificially intelligent computer, culminating in the classic The Last Question – a tale that tracks the evolution of Multivac and the human race.

Asimov recognised that computers would grow both smaller and more powerful, with Multivac transforming from a sprawling giant into an entity that exists outside of space and time. He merely underestimated the timescale – Asimov thought it would take thousands of years for Multivac to shrink to a vaguely mobile form.

All things human hang by a slender thread; and that which seemed to stand strong suddenly falls and sinks in ruins. Ovid, 43 BC – AD 18

For those of you that don’t know, PubSubHubbub is a protocol for facilitating the real-time distribution of Atom and RSS feeds. In some ways it could be considered a competitor to the RSS Cloud protocol which I wrote about last month; although, in my opinion, they really serve quite different roles.

As of right now, the PubSubHubbub protocol has no mention of security anywhere in the specification. ¹ As a point of comparison, if it were an IETF document, having a section on security considerations would be a requirement for publication.

Whether any of the attacks outlined in this post are genuine threats or not isn’t really of much consequence. I’d just like to see some sign that people are at least considering the potential for such attacks.

Fake publishing

Let’s start with publishing. When you want to let a hub know that your feed has been updated, you send it a New Content Notification. The hub should then fetch your feed to see what has changed, so it can pass on those changes to any subscribers. How does it know where to find your feed? You tell it the URL to use – any URL you want – and it will blindly trust you.

So what happens when an attacker lies, and gives the hub a URL for someone else’s feed? Then tells the hub that said feed is updating constantly – like say a thousand times a second? It requires very little bandwidth to launch such an attack (especially if the hub supports persistent connections), but can result in a substantial load on the victim’s server.

Now in an ideal world, both the hub and the feed publisher would support ETag and Last-Modified headers, which would essentially nullify any real damage from this sort of attack. However, there’s an easy way for an attacker to bypass that defence – just use a URL that isn’t actually a feed.

How do you recognise a feed?

Typically a hub won’t be sure of the kind of file it is downloading until it has actually finished downloading it. As a result, there’s really nothing stopping an attacker from “publishing” say an image, or a movie, or a multi-gigabyte ISO if they were lucky enough to find such a thing on the target server.

Not only does this mean that the victim will have to deal with a much higher load, but because the file isn’t a feed, the hub most likely won’t cache it, and won’t store ETags and Last-Modified headers. That means the next time the attacker “publishes” that URL (say a couple of milliseconds later), the hub will be forced to download the entire file all over again.

There are ways of constraining this kind of attack, say by limiting the rate at which a hub accepts new content notifications. But the attacker could then just use multiple hubs to achieve the same effect – it would require very little extra effort on their part.

Fake subscriptions

Another potential avenue of attack, involves tricking a server into subscribing to a bunch of high-traffic feeds. This then forces the hub (or hubs) to push a load of unwanted content at the target server. The server doesn’t even need to be a feed subscriber of any sort – as long as it’s listening for HTTP connections it’s a potential target.

Now the PubSubHubbub subscription mechanism does have a form of authentication to verify that the subscriber did genuinely request a subscription, but that’s fairly easy for an attacker to work around.

All they have to do is setup a temporary domain name pointing to their own server, and subscribe to a bunch of feeds as if they were a regular subscriber. Once the verification process was complete, and the hub was satisfied that the subscriptions were genuine, the attacker could then reconfigure their DNS to redirect the flood of updates to their victim’s IP address.

Now because the DNS entry is faked, the host headers in the update will obviously not match the target server. Thus, depending on how the server is configured, and the kind of web framework they are running, it’s possible this attack won’t have much effect. However, I’ve done enough testing to know that at least some server configurations would be vulnerable.

Controlling the feed source

At the end of the day, though, fake subscriptions are a fairly limited form of attack. Since data is only pushed to the victim’s server when a feed actually updates, the attacker would likely have to subscribe to hundreds of thousands of feeds to have any noticeable impact; and even then it wouldn’t be a particularly reliable attack vector.

So let’s consider a different approach. What if the attacker were providing the feed themselves? Since they have complete control over the source, they could make sure that the feed was different every time it was refreshed. And of course they could send new content notifications to the hub as frequently as they liked.

You might think that the attacker would then suffer the same bandwidth hit as the victim’s computer, but that’s not necessarily true. If the hub supports XML entity expansion (and some implementations clearly do), the attacker could easily create a feed that is minuscule on their end, but would expand considerably when pushed to the victim’s server.

Similar results can be achieved with HTTP compression. If the hub supports compressed downloads (which is highly probable), the attacker can serve up a tiny gzipped feed, that would expand into something much more massive.

Duplicate subscriptions

While the hub and target server may have mechanisms in place to limit the amount of data that can be POSTed, there is another way an attacker can magnify the attack. The trick is to subscribe multiple times – perhaps thousands of times – using a different callback URL each time; say with a random path or query string.

From the point of view of the hub, each subscription is unique, so while the attacker’s source feed is only downloaded once, the victim’s computer would be hit with thousands of notification POSTs each time there was an update.

What’s worse, since these POSTs would likely result in an error response, the hub is encouraged by the specification to retry the notification attempt, repeatedly. It’s almost as if the protocol has been designed to cause as much damage as possible.

Unintentional attacks

So far we’ve been considering deliberate attacks against specific targets, but there is also potential for unintentional (or at least undirected) attacks.

Consider a user on a home computer running some form of PubSubHubbub client software. If their ISP assigns them a dynamic IP address, as is often the case, and their connection to the Internet is disconnected, what happens to all of their subscriptions?

Sooner or later that ISP is going to recycle the IP address and assign it to another user, and that lucky user could find themselves inundated with incoming notifications that were never requested. If they also happen to be running a PubSubHubbub client, listening on the same port (not unlikely given the limited port support ²), this could cause them considerable grief.

While this scenario may not be likely, it has the potential to be quite damaging if it does occur. Home users often have limited bandwidth, and in some cases may be charged considerable fees for exceeding their download quota. They may not even realise anything is wrong until they find themselves with a massive bill at the end of the month.

Conclusions

It seems to me that the PubSubHubbub protocol is potentially quite dangerous. However, it’s equally possible that I’m wrong, the above-mentioned attacks are no threat at all, and my concerns are unfounded.

Either way, though, I think the specification is flawed in not having a section on security considerations. If nothing else, I hope that at least is something that the authors will address.

What the fuck!?

ACM has no rights to request require(*) someone to remove links to pages on the net, and it’s unfortunate that their request was complied with.

According to this page the ACM Publications Board is run by the following nasty little censoring asses:

Ronald F Boisvert (chair) - boisvert@acm.org
Holly E Rushmeier (co-chair) - holly@acm.org
Tamer M. Ozsu (vice-chair) - ozsu@acm.org

I strongly urge you to email them, with a cc to the ACM president Wendy Hall (wh@ecs.soton.ac.uk), to tell them what you really feel about ACM practicing censorship on Ke-Sen Huang’s pages (or anywhere)!

And if you have anything to do with ACM and SIGGRAPH, as people in the games industry tend to do, then I implore you to immediately stop your involvement and furthermore that you boycott their conferences (SIGGRAPH in particular) until they straighten their shit out.

Do not let their censoring of free information stand!

(*) Changed the wording here, because some dip-shit on Reddit can’t understand the message otherwise.

Similar Posts:

• SIGGRAPH and books
• More Capcom/CEDEC bean-spilling
• Programmers wanted!
• Learning patterns and the game of Flip
• My recommended books

Drop me a line

Should I?

Yes. Feel free to ask questions and write me. An interesting question is a pleasure to answer, and I really enjoy receiving feedback

How to fix capitalism

You can read new posts by RSS, email or through Facebook

The recession and the crisis and banking are the least of the reasons for thinking that we need reforms. the crisis of capitalism goes much deeper: the influence big business has on governments (and the warped policies this leads to), increasing central control of the economy and the general move away from free markets.. I have some modest proposals on how to fix capitalism.

Break up monopolies and oligopolies

Under existing competition (anti-trust in American) laws, it is necessary to prove abuse of the monopoly. This allows a business to avoid competition, because it has not been proved to have used particular practices. Competition may be locked out (for example, by network effects) and consumers may suffer from a lack of innovation or product quality, but none of that is illegal.

The solution is to assume that monopolies are harmful and should be broken up. Either this should be an invariable rule, or it should be up to the monopolist to prove that the monopoly is somehow beneficial. An exception should be made for natural monopolies, but the price of that should be tight regulation, nationalisation, or (best of all) mutualisation.

That still leaves the problem of olgopolies. The answer is simple: break up any company with enough market share to have a noticeable influence on prices — say more than 5% nationally or 10% at a city/county level. Again, they would need to make the case of exceptions.

Doing this would also mean that there would be no “too big to fail” banks, so a financial crisis would be easier to solve: let them go bust and nationalise the assets and liabilities.

Remove barriers to entry

• Abolish patents. They have not been proven to speed progress: the evidence seems to be to the contrary. They definitely increase costs, are an inefficient way of funding R & D and allow oligopolists to block competition.
• Reduce the copyright term to the optimal length suggested by research of about 15 years. It ought to be obvious that works produced in the reign of Queen Victoria should not be in copyright in the 21^st century.
• Exclude works distributed with DRM from copyright to ensure that copyright works do fall into the public domain when the copyright expires.
• Reduce the copyright term on computer software to two years, and make copyright contingent on disclosing source code (so others can alter the software when it comes out of copyright).
• Abolish region of origin rules. It should be legal to describe a Cava (when selling it) as having been made in the same way as Champagne.
• Abolish unnecessarily restrictive licensing. Many US states require people to be licensed to work as interior designers or hairdressers. I can understand requiring doctors or auditors to be licensed, but these are just barriers to entry.

Reduce bureaucracy

The best example of the problem (or opportunity from his point of view) that I have heard, is something Ted Tuppen, the founder and CEO of the huge British pub chain Enterprise Inns, said. I may not have got the wording exactly right, but, as I remember it, it was:

There will always be pubs available to buy because owners of free houses are driven out of the business by the amount of bureaucracy.

Small businesses cannot cope with tight regulation. Big businesses can hire teams of lawyers and paper-pushers. This is one of the many problems with patents. The government, far from discouraging oligopolies, is actually encouraging their formation.

Stop being “business friendly”

People seem to be thinking much less clearly about this now than they did in the 18^th century. Back then, the business friendly ideology was called “mercantilism”, and it was this was the primary source of opposition to free markets. Now, governments profess to be in favour of free markets and “business friendly”.

Of course, businesses sometimes want free markets, for example they do not want to regulated. On the other hand they also want to minimise competition, reduce costs, receive subsidies and form cartels. Businesses are usually in favour of free markets in general, but not in the specific case of their own industry.

The new mercantilism is the root cause of the problems most of my other proposals seek to solve. It has also lead to a failure to regulate properly. The obvious examples are the clear failures in the regulation of banks (such as allowing deposit takers to have high risk investment banking operations), but there are others: the US broke up Standard Oil and AT & T, but failed to break up Microsoft, reflecting the general trend towards letting businesses do as they like.

New mercantilism has dropped the one aspect of the 18^th century form that I find has some redeeming features: economic nationalism. Democracy is compromised by the economic pressure tyrants can bring in a globalised economy. I also find it extremely odd that governments will minutely examine an applicant for a holiday visa, but allow a dubious foreign tycoon to gain great influence within their country by buying influential businesses.

New mercantilism is dishonest. It does not openly oppose free markets. Instead it relies on conflating free markets with capitalism.

Financially penalise large businesses

This idea is simple. Tax big companies more. This will discourage mergers except where there are clear gains. British tax law already has lower rates for small companies, but this does not go far enough. The rates should keep increasing as companies get larger (at the moment there are no further increases on companies with profits greater than £1.5m: I would suggest bands at say £15m, £150m and £1.5bn as well). Obviously, we would need similar systems in all major economies.

The size criteria should not be based on profit. It should be based on value added: so a big company that has a bad year would not see its tax rate reduce (obviously taxes paid would do down in proportion to profit).

Give shareholders control

Shareholders are supposed to the owners of a company, but in the case of large listed companies this control is limited. This does lead to problems:

• Shareholders have to resort to expensive and disruptive means such as accepting hostile takeover bids to replace incompetent management — this also tends to encourage consolidation where there is no real economic benefit.
• Management have an incentive to focus on the short term. They can take their bonuses and leave, while accumulating problems for the future.
• Management tend to overpay themselves. As J.K. Galbraith said: “The high salary of the chief executive of a large corporation is not a market reward for achievement. It is frequently in the nature of a warm personal gesture from an individual to himself.”
• Management indulge their egos, buy engaging in exciting takeovers, and risky businesses, rather than getting on with the humdrum but reliably profitable. It is impossible to prove what people were thinking, but it is hard not to believe that this contributed to the destruction of GEC/Marconi

Reject the corrosive “greed is good” ideology

Adam Smith never intended that the idea of the “invisible hand” should be interpreted as meaning that people should pursue their own interests, and that this would lead to an optimum outcome. He wrote extensively on morality.

The reason for those troublesome bonus schemes for directors is that it is assumed that they would not run the company as well as they could unless they were “incentivised” with payments for success. This contradicts management theory: Herzberg classifies pay as a “hygine factor”, a poor motivator compared to, for example, job satisfaction.

What is even worse is that by telling people that they are expected to be selfish, they become more selfish. Economics students become more selfish because they are repeatedly taught to expect that people are rational and selfish: the association between the two can only strengthen the effect.

Society is permeated, especially in business, politics and economics, with the idea that is people pursue their own interests, this will automatically lead to the best outcome, and that, therefore, people should be selfish. This cannot be fixed by endless incentives to align interests: life and business is too complex for that to work. A free market is not a substitute for integrity.

Break the loop

What matters most is the rejection of the new mercantilism, which will at least stop things getting worse, but we still need to undo the legislation and the structures that have been put into place at the behest of the mercantilists. The two go together: the rise of the new mercantilism is partly the result of the lobbying power of large corporations. Break them up and reduce their power and they lose their influence.

Education is also important. Most people cannot, at the moment, distinguish between capitalism and free markets, or see the parallels between the original and the new mercantilism.

Comments(4)

[...] it up on my door, as it were. So here it is, in full. The full essay with all its many links is on Graeme’s site, along with many of his other thoughtful pieces, so go there if you want the Full Monty: The [...]

What a splendid manifesto. I’m nailing it to my blog.

Thanks Charles and Alan. Please note that it is under a Creative Commons attribution non-commercial no derivatives license so it can be reproduced by most blogs and other websites as long as you link back here. Commercial is OK as long as people do not have to pay to read it.

[...] Tweets about this great post on TwittLink.com [...]

Enlarge

NIST postdoctoral researcher David Hanneke at the laser table used to demonstrate the first universal programmable processor for a potential quantum computer. A pair of beryllium ions (charged atoms) that hold information in the processor are trapped inside the cylinder at the lower right. A colorized image of the two ions is displayed on the monitor in the background. Credit: J. Burrus/NIST

Physicists at the National Institute of Standards and Technology have demonstrated the first "universal" programmable quantum information
processor able to run any program allowed by quantum mechanics -- the rules governing the submicroscopic world -- using two quantum bits (qubits) of information. The processor could be a module in a future quantum computer, which theoretically could solve some important problems that are intractable today.

The NIST demonstration, described in Nature Physics, marks the first time any research group has moved beyond demonstrating individual tasks for a quantum processor—as done previously at NIST and elsewhere—to perform programmable processing, combining enough inputs and continuous steps to run any possible two-qubit program.

The NIST team also analyzed the quantum processor with the methods used in traditional computer science and electronics by creating a diagram of the processing circuit and mathematically determining the 15 different starting values and sequences of processing operations needed to run a given program. "This is the first time anyone has demonstrated a programmable quantum processor for more than one qubit," says NIST postdoctoral researcher David Hanneke, first author of the paper. "It's a step toward the big goal of doing calculations with lots and lots of qubits. The idea is you'd have lots of these processors, and you'd link them together."

The NIST processor stores binary information (1s and 0s) in two beryllium ions (electrically charged atoms), which are held in an electromagnetic trap and manipulated with ultraviolet lasers. Two magnesium ions in the trap help cool the beryllium ions.

NIST scientists can manipulate the states of each beryllium qubit, including placing the ions in a "superposition" of both 1 and 0 values at the same time, a significant potential advantage of information processing in the quantum world. Scientists also can "entangle" the two qubits, a quantum phenomenon that links the pair's properties even when the ions are physically separated.

With these capabilities, the NIST team performed 160 different processing routines on the two qubits. Although there are an infinite number of possible two-qubit programs, this set of 160 is large and diverse enough to fairly represent them, Hanneke says, making the processor "universal." Key to the experimental design was use of a random number generator to select the particular routines that would be executed, so all possible programs had an equal chance of selection. This approach was chosen to avoid bias in testing the processor, in the event that some programs ran better or produced more accurate outputs than others.

Ions are among several promising types of qubits for a quantum computer. If they can be built, quantum computers have many possible applications such as breaking today's most widely used encryption codes, such as those that protect electronic financial transactions. In addition to its possible use as a module of a quantum computer, the new processor might be used as a miniature simulator for interactions in any quantum system that employs two energy levels, such as the two-level ion qubit systems that represent energy levels as 0s and 1s. Large quantum simulators could, for example, help explain the mystery of high-temperature superconductivity, the transmission of electricity with zero resistance at temperatures that may be practical for efficient storage and distribution of electric power.

The new paper is the same NIST research group's third major paper published this year based on data from experiments with trapped ions. They previously demonstrated sustained quantum information processing and entanglement in a mechanical system similar to those in the macroscopic everyday world. NIST quantum computing research contributes to advances in national priority areas, such as information security, as well as NIST mission work in precision measurement and atomic clocks.

In the latest NIST experiments reported in Nature Physics, each program consisted of 31 logic operations, 15 of which were varied in the programming process. A logic operation is a rule specifying a particular manipulation of one or two qubits. In traditional computers, these operations are written into software code and performed by hardware.

The programs did not perform easily described mathematical calculations. Rather, they involved various single-qubit "rotations" and two-qubit entanglements. As an example of a rotation, if a qubit is envisioned as a dot on a sphere at the north pole for 0, at the south pole for 1, or on the equator for a balanced superposition of 0 and 1, the dot might be rotated to a different point on the sphere, perhaps from the northern to the southern hemisphere, making it more of a 1 than a 0.

Each program operated accurately an average of 79 percent of the time across 900 runs, each run lasting about 37 milliseconds. To evaluate the processor and the quality of its operation, NIST scientists compared the measured outputs of the programs to idealized, theoretical results. They also performed extra measurements on 11 of the 160 programs, to more fully reconstruct how they ran and double-check the outputs.

As noted in the paper, many more qubits and logic operations will be required to solve large problems. A significant challenge for future research will be reducing the errors that build up during successive operations. Program accuracy rates will need to be boosted substantially, both to achieve fault-tolerant computing and to reduce the computational "overhead" needed to correct errors after they occur, according to the paper.

As a non-regulatory agency of the U.S. Department of Commerce, NIST promotes U.S. innovation and industrial competitiveness by advancing measurement science, standards and technology in ways that enhance economic security and improve our quality of life.

More information: D. Hanneke, J.P. Home, J.D. Jost, J.M. Amini, D. Leibfried & D.J. Wineland. 2009. Realization of a programmable two-qubit quantum processor. Nature Physics. Posted online Nov. 15.

Source: National Institute of Standards and Technology (news : web)

   

• NeilFarbstein - Nov 15, 2009
  • Rank: not rated yet
  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Damon_Hastings - Nov 15, 2009
  • Rank: not rated yet
  I think it has something to do with the superposition of states allowing massively parallel computation within a single processor. In essence, the processor tries out all possible solutions to a problem simultaneously, with each potential solution represented by one state in the superposition. The correct solution is then "chosen" by the instantaneous waveform collapse (where the collapse is guided by the probability distribution function carefully crafted by the processor). Thus, the processor tries out thousands of solutions in the time it would normally take to try only one. And now put tons of those processors on the same chip!

  But I don't pretend to really understand any of this. As a computer programmer, I'm beginning to wonder whether I'm going to need QM classes to program future computers effectively...

  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Arikin - Nov 15, 2009
  • Rank: not rated yet
  Damon_Hastings, You won't need QM classes. That is the whole point of the "programs" they were testing. Abstraction from the inner hardware workings allows you the programmer to program and not think about that.

  This is almost the same process of current computers when the modern version started out. Think of room sized computers with punch cards that could barely do anything.

  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Damon_Hastings - Nov 15, 2009
  • Rank: not rated yet
  Well, the programs they were testing in this article consisted entirely of esoteric quantum operations such as "rotations" and "entanglements". Same story with all existing "quantum programming languages" listed at http://en.wikiped...gramming

  There are efforts underway to create a functional (conventional) Quantum Programming language, but they're still very much in the early stages: http://www.dcs.gl...rvey.pdf -- and they'll be... weird.

  "quantum computers raise interesting problems
  for the design of programming languages"

  "it was only in 1996 that work towards the design of [high-level Quantum Programming] languages began to be published."

  I'm certain today's programs will run on tomorrow's quantum computers, but they might not actually make use of those computers' "quantumness", i.e. the massive internal parallelism that will provide such incredible speed -- unless you translate the programs to a QP language.

  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• ReeseJ2 - Nov 16, 2009
  • Rank: not rated yet
  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Damon_Hastings - Nov 16, 2009
  • Rank: 5 / 5 (2)
  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Noumenon - Nov 16, 2009
  • Rank: not rated yet
  ".... have many possible applications such as breaking today's most widely used encryption codes, such as those that protect electronic financial transactions"

  Why would anyone want to do this?
  

  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Noumenon - Nov 16, 2009
  • Rank: not rated yet
  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• eachus - Nov 16, 2009
  • Rank: not rated yet
  Damon_Hastings:

  Man, I hope you're right. After a few hours of studying QM, I inevitably start to feel like someone must have slipped a tab of acid into my drink...

  
  You are getting there. I used to think that, "You don't need to be crazy to understand quantum menchanics, but it helps." Now I realize that anyone who understands QM had better conceal that understanding around psychiatrists. You have to think in a way that they would see as a non-functional world view.

  Will we get to the point where a classical world-view will be recognized as a special case of QM? I doubt it. The views are just too different. In a QM experiment, I have to accept that the calculated probability of a particle being in a particular place has to be understood as the particle being smeared over all possible positions. Not two places at once, but an infinite (aleph-1) number of positions.
  

  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• avacoder - Nov 16, 2009
  • Rank: not rated yet
  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5
• Noumenon - Nov 16, 2009
  • Rank: 1 / 5 (1)
  • report abuse
  • • Current rank
    • 1
    • 2
    • 3
    • 4
    • 5

(Enter a number and I'll tell you everything you wanted to know about it but were afraid to ask.)

Most of the time, we are working hard, head down, using what we know.

We get better and better at it. We make little improvements, and keep working. Our expertise and confidence keeps increasing.

We can’t afford to stop and question everything. We can’t go back to school. We have work to do.

Until we don’t.

Last year I left my company, and decided to start a new one.

I wanted to replace my old thoughts with new ones. I had been working hard, doing one thing in one mindset for ten years, and needed to install a new operating system in my brain.

I read a lot of books on business, social psychology, management, behavioral economics, investing, cognitive biases, crowds, marketing, networking, learning, and communication.

But each book that made me feel smarter (“Aha! I think I understand the world better now!”) also made me feel dumber (“Wow, I’ve been an idiot. It’s surprising I survived at all.”)

For example, when I read “What Got You Here Won’t Get You There”, I realized what a horrible manager I’d been - how I’ve been dealing with people all wrong. It felt like the author had been hiding under my desk for 10 years, making a list of what not to do, and he was right. I’ve got so much to learn to be a good manager.

Business experts like Ram Charan, Clayton Christensen, Adrian Slywotzky and Charlie Munger made me feel like a court jester next to a samurai. I long to have their insight and expertise. I could study hard for 30 years and barely catch up.

Plus an ex-employee I’d fired, and an ex-girlfriend I’d broken up with, made sure I knew what a horrible horrible person I am. Not only am I an idiot, I’m dangerous! Destroying others in my path.

It was all very humbling.

So humbling, that I found it hard to do anything at all.

I had designed and announced my new company. I was psyched for it to exist. But when it came down to doing the necessary work, I hesitated and procrastinated. “Who am I to be starting another company? I’m just going to fuck it up like last time.“

After all I’ve learned, I can’t believe anyone actually thinks they’ll succeed in the complex world of business. Don’t they see all the really smart people who have tried and failed?

I can’t believe how foolish I was to start my first company. Just me in my bedroom with no experience, making a little website, when I was up against giant IPO-funded competitors.

I was an over-confident punk, thinking I had the answer, and everyone else didn’t.

But it worked.

And in fact, isn’t that kind of confidence absolutely required to get anything done?

Isn’t the role of the entrepreneur to be the bold, daring, audacious one? The over-confident reckless one who says, “Screw it. Let’s do it!”?

Yes! Of course! It’s the essential final lesson: that all this learning means nothing until you make something happen.

Whether you think you'll win or not - you need to jump in the game, and say, “Let’s go!”

Whether your confidence is naïve, inspired or crafted - you need its high-horsepower engine to get uphill and go anywhere.

And no matter how humbling the lessons of life are, this final lesson is the most important of all.

And thus, I graduated from my self-created Entrepreneur 102 class.

Time to go make something happen.

Refine your online advertising with Google Ad Planner, a free media planning tool that can help you:

• Define audiences by demographics and interests.
• Search for websites relevant to your target audience.
• Access unique users, page views, and other data for millions of websites from over 40 countries.

• Create lists of websites where you'd like to advertise.
• Generate aggregated website statistics for your media plan.

Below is a copy of the $9,000,000,000.00 check.

Too Big to Fail: The $9 Billion Japanese Check to Morgan Stanley

BANGALORE -- Hair tucked into a surgical cap, eyes hidden behind thick-framed magnifying glasses, Devi Shetty leans over the sawed open chest of an 11-year-old boy, using bright blue thread to sew an artificial aorta onto his stopped heart.

As Dr. Shetty pulls the thread tight with scissors, an assistant reads aloud a proposed agreement for him to build a new hospital in the Cayman Islands that would primarily serve Americans in search of lower-cost medical care. The agreement is inked a few days later, pending approval of the Cayman parliament.

Dr. Shetty, who entered the limelight in the early 1990s as Mother Teresa's cardiac surgeon, offers cutting-edge medical care in India at a fraction of what it costs elsewhere in the world. His flagship heart hospital charges $2,000, on average, for open-heart surgery, compared with hospitals in the U.S. that are paid between $20,000 and $100,000, depending on the complexity of the surgery.

The approach has transformed health care in India through a simple premise that works in other industries: economies of scale. By driving huge volumes, even of procedures as sophisticated, delicate and dangerous as heart surgery, Dr. Shetty has managed to drive down the cost of health care in his nation of one billion.

His model offers insights for countries worldwide that are struggling with soaring medical costs, including the U.S. as it debates major health-care overhaul.

"Japanese companies reinvented the process of making cars. That's what we're doing in health care," Dr. Shetty says. "What health care needs is process innovation, not product innovation."

At his flagship, 1,000-bed Narayana Hrudayalaya Hospital, surgeons operate at a capacity virtually unheard of in the U.S., where the average hospital has 160 beds, according to the American Hospital Association.

Narayana's 42 cardiac surgeons performed 3,174 cardiac bypass surgeries in 2008, more than double the 1,367 the Cleveland Clinic, a U.S. leader, did in the same year. His surgeons operated on 2,777 pediatric patients, more than double the 1,026 surgeries performed at Children's Hospital Boston.

Next door to Narayana, Dr. Shetty built a 1,400-bed cancer hospital and a 300-bed eye hospital, which share the same laboratories and blood bank as the heart institute. His family-owned business group, Narayana Hrudayalaya Private Ltd., reports a 7.7% profit after taxes, or slightly above the 6.9% average for a U.S. hospital, according to American Hospital Association data.

The group is fueling its expansion plans through private equity, having raised $90 million last year. The money is funding four more "health cities" under construction around India. Over the next five years, Dr. Shetty's company plans to take the number of total hospital beds to 30,000 from about 3,000, which would make it by far the largest private-hospital group in India.

At that volume, he says, he would be able to cut costs significantly more by bypassing medical equipment sellers and buying directly from suppliers.

Then there are the Cayman Islands, where he plans to build and run a 2,000-bed general hospital an hour's plane ride from Miami. Procedures, both elective and necessary, will be priced at least 50% lower than what they cost in the U.S., says Dr. Shetty, who hopes to draw Americans who are uninsured or need surgery their plans don't cover.

By next year, six million Americans are expected to travel to other countries in search of affordable medical care, up from the 750,000 who did so in 2007, according to a report by Deloitte LLP. A handful of U.S. insurance plans now give people the choice to be treated in other countries.

Some in India question whether Dr. Shetty is taking his high volume model too far, risking quality.

"On one level, it's a damn good idea. My only issue with it comes from the fact that if you pursue wholesale volumes, you may give up something -- which is usually quality," says Amit Varma, a physician who serves as president of health-care initiatives for Religare Enterprises Ltd., a publicly listed financial services group in Delhi. Religare is part of a conglomerate that also owns Fortis Healthcare Ltd., a rival hospital chain.

"I think he has reached the point where if you increase volume any more, you could compromise patient care unless backed up by very robust standard operating procedures and processes," Dr. Varma says.

But Jack Lewin, chief executive of the American College of Cardiology, who visited Dr. Shetty's hospital earlier this year as a guest lecturer, says Dr. Shetty has done just the opposite -- used high volumes to improve quality. For one thing, some studies show quality rises at hospitals that perform more surgeries for the simple reason that doctors are getting more experience. And at Narayana, says Dr. Lewin, the large number of patients allows individual doctors to focus on one or two specific types of cardiac surgeries.

In smaller U.S. and Indian hospitals, he says, there aren't enough patients for one surgeon to focus exclusively on one type of heart procedure.

Narayana surgeon Colin John, for example, has performed nearly 4,000 complex pediatric procedures known as Tetralogy of Fallot in his 30-year career. The procedure repairs four different heart abnormalities at once. Many surgeons in other countries would never reach that number of any type of cardiac surgery in their lifetimes.

Dr. Shetty's success rates appear to be as good as those of many hospitals abroad. Narayana Hrudayalaya reports a 1.4% mortality rate within 30 days of coronary artery bypass graft surgery, one of the most common procedures, compared with an average of 1.9% in the U.S. in 2008, according to data gathered by the Chicago-based Society of Thoracic Surgeons.

It isn't possible truly to compare the mortality rates, says Dr. Shetty, because he doesn't adjust his mortality rate to reflect patients' ages and other illnesses, in what is known as a risk-adjusted mortality rate. India's National Accreditation Board for Hospitals & Healthcare Providers asks hospitals to provide their mortality rates for surgery, without risk adjustment.

Dr. Lewin believes Dr. Shetty's success rates would look even better if he adjusted for risk, because his patients often lack access to even basic health care and suffer from more advanced cardiac disease when they finally come in for surgery.

Dr. Shetty, 54 years old, is a lanky and chatty man. He grew up in Mangalore, another south Indian city, the eighth of nine children. Doctors were gods in the Shetty household, swooping in to save his restaurateur father who suffered from chronic diabetes and fell into diabetic comas several times in the young boy's life.

He had already resolved to be a doctor when his fifth-grade teacher told the class that a South African surgeon had just performed the world's first heart transplant. In that moment, Dr. Shetty says he decided to become a heart surgeon.

After graduating from medical college in India, Dr. Shetty trained in cardiac surgery at Guy's Hospital in London, one of Europe's top medical facilities. He had been operating there for six years when the Birla family, leading industrialists in India, decided to start a heart hospital in Calcutta. Dr. Shetty was brought in as the first director.

On returning to India in 1989, Dr. Shetty performed the first neonatal heart surgery in the country on a 9-day-old baby. He also confronted the reality that almost none of the patients who came to him could pay the $2,400 cost of open-heart surgery.

"When I told patients the cost, they would disappear. They literally didn't even ask about lowering the price," he says.

During that time, Mother Teresa had a heart attack, and Dr. Shetty was called to operate on her. From then on, he served as her personal physician. Two pictures of Mother Teresa still adorn the white walls of Dr. Shetty's office, one with white type saying, "Hands that serve are more sacred than lips that pray."

Dr. Shetty set about pursuing a heart hospital big enough to make a difference in a country where most of the people needing heart surgery can't afford it. His father-in-law, the owner of a large construction company, agreed to build and finance a heart hospital in his wife's hometown of Bangalore.

In 2001, the white-washed, red-roofed Narayana Hrudayalaya Hospital opened on 25 acres that had been a marshland around a cement factory.

A lobby with seating for hundreds is encircled by dozens of offices for surgeons to consult with patients. A giant statue of a many-headed deity -- representing gods in the Hindu pantheon -- stands in the center of the lobby.

In a second-floor operating room one October morning, Dr. Shetty finished sewing a new aorta onto the heart of his 11-year-old patient. The process provided an example of how he slashes costs. Four years ago, the sutures would have been bought from a Johnson & Johnson subsidiary. Today they are made by a Mumbai company, Centennial Surgical Suture Ltd.

Four years ago, Dr. Shetty scrutinized his annual bill for sutures -- then $100,000 and rising by about 5% each year. He made the switch to cheaper sutures by Centennial, cutting his expenditures in half to $50,000.

"In health care you can't do one big thing and reduce the price," Dr. Shetty says. "We have to do 1,000 small things."

He says he would also like to find lower-cost versions of his priciest medical equipment. But the Chinese makers that have brought good quality, cheaper machines to market don't yet have enough local service centers to ensure regular maintenance.

So he is still buying equipment from General Electric Co. He pays $60,000 for echocardiography machines, which use sound waves to create a moving image of the heart, and $750,000 for cardiac catheterization labs, which produce images of blood flow in the arteries and allow surgeons to clear some blockages using stents and other devices.

V. Raja, head of GE's health-care business in India, declined to comment on specific pricing, but says Dr. Shetty drives a hard bargain and wrestles some savings because he is such a big customer. Between Narayana Hrudayalaya and another hospital he runs in Calcutta, Dr. Shetty's group performs 12% of India's cardiac surgeries, Mr. Raja says.

Dr. Shetty also gets more use out of each machine by using some of them 15 to 20 times a day, at least five times more than the typical U.S. hospital.

Cardiac surgeons at Dr. Shetty's hospitals are paid the going rate in India, between $110,000 and $240,000 annually, depending on experience, says Viren Shetty, a director of the hospital group and one of Dr. Shetty's sons.

Dr. Shetty was paid almost $500,000 last year, according to the group's audited financial statements.

Here, too, Dr. Shetty finds additional savings on the per-patient cost. His surgeons perform two or three procedures a day, six days a week. They typically work 60 to 70 hours a week, they say. Residents work the same number of hours.

In comparison, surgeons in the U.S. typically perform one or two surgeries a day, five days a week, operating fewer than 60 hours.

Dr. Shetty says doctor fatigue isn't an issue at his hospital, and in general, his surgeons take breaks after three or four hours in surgery. The morning after Dr. Shetty operated on 11-year-old Mahesh Parashivappa, the boy sat in bed in the pediatric intensive care unit, a white bandage on his bare chest.

Virtually all of the 80 beds in the unit were full. K. Parashivappa, the boy's father, a sugarcane worker from a village eight hours away, held a cup of water to his son's lips. He says he's known his son needed surgery since he was born with a congenital heart defect. The boy has never been able to run and play cricket like other children, hobbled by chronic shortness of breath and weakness.

Mr. Parashivappa says he can't himself pay for the surgery, but it is covered by a farmers' insurance plan that Dr. Shetty began several years ago in partnership with the state of Karnataka, which includes Bangalore.

Nearly one third of the hospital's patients are enrolled in this insurance plan, which costs $3 a year per person and reimburses the hospital $1,200 for each cardiac surgery.

That is about $300 below the hospital's break-even cost of $1,500 per surgery.

The hospital makes up the difference by charging $2,400 to the 40% of its patients in the general ward who aren't enrolled in the plan. An additional 30% who opt for private or semi-private rooms pay as much as $5,000.

The father, in an untucked brown shirt, raised both hands to offer the traditional Indian greeting, "Namaste," to Dr. Shetty as the hospital head stopped by his son's bed. "Thank you for giving my son his life back."

Write to Geeta Anand at geeta.anand@wsj.com

flixel

I really, really enjoy writing JavaScript code so I decided to read through the article and take a look at the node.js library linked there.

Node is a framework to build server-side event-driven JavaScript applications. Developed in Python on top of Google’s V8 JavaScript engine Node seems to make building distributed (over a network), fast applications a piece of cake even for inexperienced developers.
Event-driven here really is the keyword because it represent a big change in the way applications are built (and architected in your brain).

Node is similar in design to and influenced by systems like Ruby’s Event Machine or Python’s Twisted. Node takes the event model a bit further—it presents the event loop as a language construct instead of as a library. In other systems there is always a blocking call to start the event-loop. Typically one defines behavior through callbacks at the beginning of a script and at the end starts a server through a blocking call like

. In Node there is no such start-the-event-loop call. Node simply enters the event loop after executing the input script.

The example below (taken from Node’s website) will make everything clear… hopefully.

Can you see the beauty?!

I have only one worry. This is an open-source effort. The community behind it on Google groups is just 181 members strong (so far). What if node.js suddenly stops being the cool thing and the community disappears.

As much as I love writing JavaScript and I can really see the value in what they are building I’ll still wait until there are 100 Google Groups for node.js and a trillion members in each before using it in anything close to a production system.

Having said that I’m going back to writing silly node.js apps now. Well done to all the developers involved in the project and keep it up!

November 2009

I don't think Apple realizes how badly the App Store approval process is broken. Or rather, I don't think they realize how much it matters that it's broken.

The way Apple runs the App Store has harmed their reputation with programmers more than anything else they've ever done. Their reputation with programmers used to be great. It used to be the most common complaint you heard about Apple was that their fans admired them too uncritically. The App Store has changed that. Now a lot of programmers have started to see Apple as evil.

How much of the goodwill Apple once had with programmers have they lost over the App Store? A third? Half? And that's just so far. The App Store is an ongoing karma leak.

How did Apple get into this mess? Their fundamental problem is that they don't understand software.

They treat iPhone apps the way they treat the music they sell through iTunes. Apple is the channel; they own the user; if you want to reach users, you do it on their terms. The record labels agreed, reluctantly. But this model doesn't work for software. It doesn't work for an intermediary to own the user. The software business learned that in the early 1980s, when companies like VisiCorp showed that although the words "software" and "publisher" fit together, the underlying concepts don't. Software isn't like music or books. It's too complicated for a third party to act as an intermediary between developer and user. And yet that's what Apple is trying to be with the App Store: a software publisher. And a particularly overreaching one at that, with fussy tastes and a rigidly enforced house style.

If software publishing didn't work in 1980, it works even less now that software development has evolved from a small number of big releases to a constant stream of small ones. But Apple doesn't understand that either. Their model of product development derives from hardware. They work on something till they think it's finished, then they release it. You have to do that with hardware, but because software is so easy to change, its design can benefit from evolution. The standard way to develop applications now is to launch fast and iterate. Which means it's a disaster to have long, random delays each time you release a new version.

Apparently Apple's attitude is that developers should be more careful when they submit a new version to the App Store. They would say that. But powerful as they are, they're not powerful enough to turn back the evolution of technology. Programmers don't use launch-fast-and-iterate out of laziness. They use it because it yields the best results. By obstructing that process, Apple is making them do bad work, and programmers hate that as much as Apple would.

How would Apple like it if when they discovered a serious bug in OS X, instead of releasing a software update immediately, they had to submit their code to an intermediary who sat on it for a month and then rejected it because it contained an icon they didn't like?

By breaking software development, Apple gets the opposite of what they intended: the version of an app currently available in the App Store tends to be an old and buggy one. One developer told me:

As a result of their process, the App Store is full of half-baked applications. I make a new version almost every day that I release to beta users. The version on the App Store feels old and crappy. I'm sure that a lot of developers feel this way: One emotion is "I'm not really proud about what's in the App Store", and it's combined with the emotion "Really, it's Apple's fault."

I believe that they think their approval process helps users by ensuring quality. In reality, bugs like ours get through all the time and then it can take 4-8 weeks to get that bug fix approved, leaving users to think that iPhone apps sometimes just don't work. Worse for Apple, these apps work just fine on other platforms that have immediate approval processes.

They get away with maltreating developers, in the short term, because they make such great hardware. I just bought a new 27" iMac a couple days ago. It's fabulous. The screen's too shiny, and the disk is surprisingly loud, but it's so beautiful that you can't make yourself care.

So I bought it, but I bought it, for the first time, with misgivings. I felt the way I'd feel buying something made in a country with a bad human rights record. That was new. In the past when I bought things from Apple it was an unalloyed pleasure. Oh boy! They make such great stuff. This time it felt like a Faustian bargain. They make such great stuff, but they're such assholes. Do I really want to support this company?

Should Apple care what people like me think? What difference does it make if they alienate a small minority of their users?

There are a couple reasons they should care. One is that these users are the people they want as employees. If your company seems evil, the best programmers won't work for you. That hurt Microsoft a lot starting in the 90s. Programmers started to feel sheepish about working there. It seemed like selling out. When people from Microsoft were talking to other programmers and they mentioned where they worked, there were a lot of self-deprecating jokes about having gone over to the dark side. But the real problem for Microsoft wasn't the embarrassment of the people they hired. It was the people they never got. And you know who got them? Google and Apple. If Microsoft was the Empire, they were the Rebel Alliance. And it's largely because they got more of the best people that Google and Apple are doing so much better than Microsoft today.

Why are programmers so fussy about their employers' morals? Partly because they can afford to be. The best programmers can work wherever they want. They don't have to work for a company they have qualms about.

But the other reason programmers are fussy, I think, is that evil begets stupidity. An organization that wins by exercising power starts to lose the ability to win by doing better work. And it's not fun for a smart person to work in a place where the best ideas aren't the ones that win. I think the reason Google embraced "Don't be evil" so eagerly was not so much to impress the outside world as to inoculate themselves against arrogance. [1]

That has worked for Google so far. They've become more bureaucratic, but otherwise they seem to have held true to their original principles. With Apple that seems less the case. When you look at the famous 1984 ad now, it's easier to imagine Apple as the dictator on the screen than the woman with the hammer. [2] In fact, if you read the dictator's speech it sounds uncannily like a prophecy of the App Store.

We have triumphed over the unprincipled dissemination of facts.

We have created, for the first time in all history, a garden of pure ideology, where each worker may bloom secure from the pests of contradictory and confusing truths. The other reason Apple should care what programmers think of them is that when you sell a platform, developers make or break you. If anyone should know this, Apple should. VisiCalc made the Apple II.

And programmers build applications for the platforms they use. Most applications—most startups, probably—grow out of personal projects. Apple itself did. Apple made microcomputers because that's what Steve Wozniak wanted for himself. He couldn't have afforded a minicomputer. [3] Microsoft likewise started out making interpreters for little microcomputers because Bill Gates and Paul Allen were interested in using them. It's a rare startup that doesn't build something the founders use.

The main reason there are so many iPhone apps is that so many programmers have iPhones. They may know, because they read it in an article, that Blackberry has such and such market share. But in practice it's as if RIM didn't exist. If they're going to build something, they want to be able to use it themselves, and that means building an iPhone app.

So programmers continue to develop iPhone apps, even though Apple continues to maltreat them. They're like someone stuck in an abusive relationship. They're so attracted to the iPhone that they can't leave. But they're looking for a way out. One wrote:

While I did enjoy developing for the iPhone, the control they place on the App Store does not give me the drive to develop applications as I would like. In fact I don't intend to make any more iPhone applications unless absolutely necessary. [4]

Is the future of handheld devices one locked down by Apple? It's a worrying prospect. It would be a bummer to have another grim monoculture like we had in the 1990s. In 1995, writing software for end users was effectively identical with writing Windows applications. Our horror at that prospect was the single biggest thing that drove us to start building web apps.

At least we know now what it would take to break Apple's lock. You'd have to get iPhones out of programmers' hands. If programmers used some other device for mobile web access, they'd start to develop apps for that instead.

How could you make a device programmers liked better than the iPhone? It's unlikely you could make something better designed. Apple leaves no room there. So this alternative device probably couldn't win on general appeal. It would have to win by virtue of some appeal it had to programmers specifically.

One way to appeal to programmers is with software. If you could think of an application programmers had to have, but that would be impossible in the circumscribed world of the iPhone, you could presumably get them to switch.

That would definitely happen if programmers started to use handhelds as development machines—if handhelds displaced laptops the way laptops displaced desktops. You need more control of a development machine than Apple will let you have over an iPhone.

Could anyone make a device that you'd carry around in your pocket like a phone, and yet would also work as a development machine? It's hard to imagine what it would look like. But I've learned never to say never about technology. A phone-sized device that would work as a development machine is no more miraculous by present standards than the iPhone itself would have seemed by the standards of 1995.

My current development machine is a MacBook Air, which I use with an external monitor and keyboard in my office, and by itself when traveling. If there was a version half the size I'd prefer it. That still wouldn't be small enough to carry around everywhere like a phone, but we're within a factor of 4 or so. Surely that gap is bridgeable. In fact, let's make it an RFS. Wanted: Woman with hammer.

Notes

[1] When Google adopted "Don't be evil," they were still so small that no one would have expected them to be, yet.

[2] The dictator in the 1984 ad isn't Microsoft, incidentally; it's IBM. IBM seemed a lot more frightening in those days, but they were friendlier to developers than Apple is now.

[3] He couldn't even afford a monitor. That's why the Apple I used a TV as a monitor.

[4] Several people I talked to mentioned how much they liked the iPhone SDK. The problem is not Apple's products but their policies. Fortunately policies are software; Apple can change them instantly if they want to. Handy that, isn't it?

Thanks to Sam Altman, Trevor Blackwell, Ross Boucher, James Bracy, Gabor Cselle, Patrick Collison, Jason Freedman, John Gruber, Joe Hewitt, Jessica Livingston, and Robert Morris for reading drafts of this.

Kwabena Boahen’s love affair with digital computers began and ended in 1981, when he was 16.

Boahen lived outside the city of Accra in the West African nation of Ghana. His family’s sprawling block house stood in a quiet field of mango and banana trees. One afternoon Boahen’s father rolled down the driveway with a surprise in the trunk of his Peugeot: a RadioShack TRS-80—the family’s first computer—purchased in England.

Young Boahen parked the machine at a desk on the porch, where he usually dismantled radios and built air guns out of PVC pipe. He plugged the computer into a TV set to provide a screen and a cassette recorder so he could store programs on tapes, and soon he was programming it to play Ping-Pong. But as he read about the electronics that made it and all other digital computers work, he soured on the toy.

Moving the Ping-Pong ball just one pixel across the screen required thousands of 1s and 0s, generated by transistors in the computer’s processor that were switching open and shut 2.5 million times per second. Boahen had expected to find elegance at the heart of his new computer. Instead he found a Lilliputian bureaucracy of binary code. “I was totally disgusted,” he recalls. “It was so brute force.” That disillusionment inspired a dream of a better solution, a vision that would eventually guide his career.

Boahen has since crossed the Atlantic Ocean and become a prominent scientist at Stanford University in California. There he is working to create a computer that will fulfill his boyhood vision—a new kind of computer, based not on the regimented order of traditional silicon chips but on the organized chaos of the human brain. Designing this machine will mean rejecting everything that we have learned over the past 50 years about building computers. But it might be exactly what we need to keep the information revolution going for another 50.

The human brain runs on only about 20 watts of power, equal to the dim light behind the pickle jar in your refrigerator. By contrast, the computer on your desk consumes a million times as much energy per calculation. If you wanted to build a robot with a processor as smart as the human brain, it would require 10 to 20 megawatts of electricity. “Ten megawatts is a small hydroelectric plant,” Boahen says dismissively. “We should work on miniaturizing hydroelectric plants so we can put them on the backs of robots.” You would encounter similar problems if you tried to build a medical implant to replace just 1 percent of the neurons in the brain, for use in stroke patients. That implant would consume as much electricity as 200 households and dissipate as much heat as the engine in a Porsche Boxster.

“Energy efficiency isn’t just a matter of elegance. It fundamentally limits what we can do with computers,” Boahen says. Despite the amazing progress in electronics technology—today’s transistors are 1/100,000 the size that they were a half century ago, and computer chips are 10 million times faster—we still have not made meaningful progress on the energy front. And if we do not, we can forget about truly intelligent humanlike machines and all the other dreams of radically more powerful computers.

Getting there, Boahen realized years ago, will require rethinking the fundamental balance between energy, information, and noise. We encounter the trade-offs this involves every time we strain to hear someone speaking through a crackly cell phone connection. We react instinctively by barking more loudly into the phone, trying to overwhelm the static by projecting a stronger signal. Digital computers operate with almost zero noise, but operating at this level of precision consumes a huge amount of power—and therein lies the downfall of modern computing.

In the palm of his hand, Boahen flashes a tiny, iridescent square, a token of his progress in solving that problem. This silicon wafer provides the basis for a new neural supercomputer, called Neurogrid, that he has nearly finished building. The wafer is etched with millions of transistors like the ones in your PC. But beneath that veneer of familiarity hides a radical rethinking of the way engineers do business.

Traditional digital computers depend on millions of transistors opening and closing with near perfection, making an error less than once per 1 trillion times. It is impressive that our computers are so accurate—but that accuracy is a house of cards. A single transistor accidentally flipping can crash a computer or shift a decimal point in your bank account. Engineers ensure that the millions of transistors on a chip behave reliably by slamming them with high voltages—essentially, pumping up the difference between a 1 and a 0 so that random variations in voltage are less likely to make one look like the other. That is a big reason why computers are such power hogs.

Radically improving that efficiency, Boahen says, will involve trade-offs that would horrify a chip designer. Forget about infinitesimal error rates like one in a trillion; the transistors in Neurogrid will crackle with noise, misfiring at rates as high as 1 in 10. “Nobody knows how we’re going to compute with that,” Boahen admits. “The only thing that computes with this kind of crap is the brain.”

It sounds cockamamy, but it is true. Scientists have found that the brain’s 100 billion neurons are surprisingly unreliable. Their synapses fail to fire 30 percent to 90 percent of the time. Yet somehow the brain works. Some scientists even see neural noise as the key to human creativity. Boahen and a small group of scientists around the world hope to copy the brain’s noisy calculations and spawn a new era of energy-efficient, intelligent computing. Neurogrid is the test to see if this approach can succeed.

Most modern supercomputers are the size of a refrigerator and devour $100,000 to $1 million of electricity per year. Boahen’s Neurogrid will fit in a briefcase, run on the equivalent of a few D batteries, and yet, if all goes well, come close to keeping up with these Goliaths.

The problem of computing with noise first occurred to a young neuro­scientist named Simon Laughlin three decades ago. Laughlin, then at the Australian National University in Canberra, spent much of 1975 sitting in a black-walled, windowless laboratory with the lights off. The darkness allowed him to study the retinas of blowflies captured from Dumpsters around campus. In hundreds of experiments he glued a living fly to a special plastic platform under a microscope, sunk a wisp-thin electrode into its honeycombed eye, and recorded how its retina responded to beams of light. Laughlin would begin recording at noon and finish after midnight. As he sat in the gloomy lab, watching neural signals dance in green light across an oscilloscope, he noticed something strange.

Each fly neuron’s response to constant light jittered up and down from one milli­second to the next. Those fluctuations showed up at every step in the neurons’ functioning, from the unreliable absorption of light by pigment molecules to the sporadic opening of electricity-conducting proteins called ion channels on the neurons’ surfaces. “I began to realize that noise placed a fundamental limit on the ability of neurons to code information,” Laughlin says.

It’s been a while since I’ve written a blog post. Poker hasn’t really picked up any for me, but I felt like I should keep writing in this blog and try my best to keep it alive in some way. Today I’m going to sell out a bit and write not about myself, but about online poker and recent events. My topic is vague enough that this post may wander through different topics, but it will be centered around Isildur and his recent appearance in high stakes online poker. It is largely a product of my curiosity, experience, and confusion, and I hope that some of these ideas might speak to some of you as well.

One of the reasons why I wanted to write something like this was because, as most of you know, we have just witnessed a monumental event in the history of online poker – the entrance of Isildur into our world of online poker. A number of other commentators have offered their insight on this event, and there’s no doubt that the commotion over him has rocked the world of high stakes online poker. I felt that given the huge amount of speculation, misinformation, and downright stupidity that has flooded twoplustwo and other forums, it wouldn’t hurt to give the less informed half of the poker world a more accurate glimpse of the high stakes poker world.

A Word of Warning

It’s important to understand that what Isildur has done (and how hot he has run) is truly amazing. It is also important to understand that almost every high stakes poker player who has insight into him or the dynamics that are occurring around him are all public figures. What I mean by that is that they either have some sort of a sponsorship or an otherwise monetary or emotional connection to their own reputation. This gives everyone two layers of incentives – the first incentive is to openly talk about him, since everybody else wants to know about Isildur and only a small group of people can actually say anything meaningful about him. The second incentive is to stay quiet – since Isildur is very much a player in the online poker world, nobody wants to say anything about him that could jeopardize or negatively affect their relationship with him as an opponent in a poker game.  What I mean to say is that anybody who right now would speak about Isildur is going to speak discreetly. Nobody will be direct, and yet everyone acknowledges his enormity. He’s going to be the elephant in the room. You won’t hear any outright admissions of how good he is, who thinks who is better than who, or even who people think Isildur is. And that’s just the nature of the game. The social dynamics of online poker have changed in the last few years, and the reaction to Isildur has shown us some of that.

What I want you the reader to understand is that I will not say everything that I think about Isildur. Nobody will. Online poker is at its heart a secretive industry, but as obvious as that is, I want to say this outright because I hope it will give some of you the awareness to look more closely at the discourse of online poker. Not everything is as it seems, and the asymmetry of information is as real here as it is anywhere else.

The Story of Isildur

That being said, it’s very obvious that Isildur is an extremely good NLHU and HUPLO player. His grasp of handreading, leveling and betsizing is second to none. Nobody who has watched Isildur play from the rail has any idea what kind of a player he is except that he seems to be aggressive and overbets a lot, and of course that he wins – his betting patterns, his style of reasoning, and his depth of thought are aspects that can only be appreciated within an actual match and by a player of adequate skill – that’s the nature of online poker. Isildur is a very good player and with the results he’s had, it’s impossible to deny it. He has rocked the boat in a big way, which is best exemplified by Tom “Durrrr” Dwan and the match they played, which is at this point a legendary one in the history of online poker.

For those of you who don’t know, Isildur won more than 3 million USD from Durrrr, which adds up to well over 30 buyins won. I’m not sure exactly how many hands were played, but as far as I know it was over 30,000 hands.  It was an epic match, and I mean that in the strongest sense of the word. Allow me to contextualize it a bit.

(Disclaimer: some of this may be inaccurate, I’m piecing this together from what I know with little to no extraneous research. But for the most part it’s true enough.)

Isildur first showed up on Full Tilt around 25/50 NLHE. I don’t know who the first person he played was, but I remember hearing about him from some 25/50 grinders who had played him or had seen him around. The word was that Isildur was the new semireg on the block. Supposedly, he was hyperaggro, barreled like a monkey, and was really easy to get to stick his stacks in.  Of course there are some 25/50 regs for whom this description was not enough to play a non-clueless opponent, but a number of regs were thrilled to have a new reg willing to play a bunch of tables and donk off stacks. Among the first few to play him in extended matches were Jungleman and I Win Flips (Tcorbin16). From what I heard from both of them, they both thought that they had significant edges on Isildur, although Corbin actually lost a decent clip to him (in typical Corbin fashion).

Our Battle

About a week later I was sitting at tables without any action when Isildur showed up at one of my 25/50 NL tables. I was bored and willing to play anything, so when he offered to play 6 tables (although usually I max out at 4), I decided to take him up on his offer and play a serious NLHE HU match for the first time in a long while. As the match progressed, all of what I’d heard about him being hyperaggro and barrelly checked out, but as I watched the lines he took to bluff, valuebet, and the way he reacted to my betting patterns, he seemed uncannily perceptive. Nevertheless, within the first hour or so I had won about 30k and was feeling pretty confident.  He sat out on all of the tables and I assumed that the match was over and was about to check out. But about a minute later he said “brb,” and so I decided to wait for him and continue the match.

From that point, I started losing. Bad. There weren’t really any particular pots where I got badly outplayed, but before I knew it, due to beats coolers and him outmaneuvering me in a few spots, he was up 50k. 6-tabling 25/50 that’s not an unheard of swing to one opponent, so I asked him if he wanted to take it up to 50/100NL. He agreed, and we played a very short session there where I just repeatedly ran into the nuts –  I thought I played well, but somehow he always had the best hand, despite his aggressiveness and how many big pots he was getting into. After losing 5 buyins at 50/100 I decided I’d had enough, and wasn’t feeling that great about my NL game and didn’t feel any point in going forward when he had all of the momentum and seemed to know my game pretty well. I told him GG and quit all of the tables.

Ten minutes later, he sat with me at 100/200 PLO, telling me he was bored and just wanted some action. I consulted my friend who told me that he had played Isildur and had crushed him – Isildur is clueless, he said. So I shrugged my shoulders and went with it – I have a lot of confidence in my PLO game, and I know that there are only a few people in the world who can come out on top against me there. If he’s as degenerate as he seems, it’s possible that I have a huge edge and that he just dumps it back. So I played.

PLO is quite different from NL because it’s much more transparent, not just to observers but also to the players themselves.  When hands get in or big pots are played, it’s often a lot easier to dissect ranges, understand decisions, and evaluate EV than it is in NL. What that means that, for both observers and for the players themselves, it’s a lot easier to see who’s running bad and who’s getting outplayed in PLO compared to NL. Well, I ended up losing about 400k to him at PLO, and according to HEM I ran 300k below EV. We played probably 1000 hands or less of PLO. It was a bloodbath, but not quite a slaughter, since the poker gods were doing a lot more of the work than he was, which will happen in PLO. At the time I was pretty devastated, but after having reviewed the match carefully, I am sure that I ran bad. I’m not sure that I had an edge, but I am sure that my expectation was nowhere near what I lost, or even a quarter of that. But to all of you, I was only the beginning of the story of Isildur.

The Rise of Isildur

After I lost to him I took a break from playing, but there was a lot of chatter on NVG and among other high stakes players about this Isildur fellow. Since I’m a fish, most weren’t phased by seeing me lose so much to him, and wanted to try their hand. The next up to bat was Ugotabanana, an 18 year old PLO extraordinaire. He’s well known for being an enormous lucksack (I love you Harry), but even he could not overcome the Promethean run-good of Isildur. He lost 250k over 5000 hands of 100/200 PLO. Again, not a lot for the stakes played and variance, but at this point Isildur’s run was starting to border on the horizon of statistical significance.

Over the next few days I wasn’t watching as closely, but apparently he undertook matches with Cole South, Brian Hastings, and Brian Townsend in both PLO and NL. The matches were very back and forth and were grabbing the attention of a lot of railbirds and high stakes players alike. Generally when top class players like Cole and Townsend are swooping in to play a bunch of tables with a new player, the new player ends up going bust pretty quick, but despite tripping up every now and then, Isildur seemed to be holding his ground. They were playing as high as 200/400 and 300/600; stacks were being thrown around and leads were sometimes taken, but never held onto. Nobody doubted that Isildur was losing, it was only a matter of when. He seemed to be solid and certainly not easy to beat, but against the titans of online poker, nobody gave him a chance.

It was after a couple of days of battling against these players, Isildur being up a decent but by no means decisive amount on his opponents, that Durrrr entered into the fray. Right off the bat they agreed to 6-table HU at 300/600NL, and it was at that point that all eyes turned to what was inevitably going to be one of the most memorable matches in the history of online poker. Despite being overshadowed by the televised WSOP main event, tens of thousands of online poker players and poker aficionados logged onto Full Tilt to observe these games. The 300/600 didn’t last long, after a short while of playing and being down a few buyins Durrrr asked Isildur to take it to 500/1000 and Isildur happily agreed. What followed then was one of the most aggressive, volatile, intense heads up matches ever played. I will do my best to resist characterizing the dynamics or what specifically occurred in the match, but I think it was best described by a phrase I used at the time – “an unstoppable force meets an immovable object,” the former being Isildur and the latter being Durrrr. It was one of those rare heads up matches that exemplifies at once both art and spectacle. Railbirds couldn’t get enough.

After the first day with a ton of back and forth and a lot of action, Isildur ended up around +1.5M. Despite having played for a very long session with few breaks, few observers thought that this win was conclusive, despite being over 15 buyins in winnings for Isildur. Before Durrrr finally quit the session he and Isildur made an agreement to play again the next day, and so when night fell again (in the USA), the match continued.

That session was the most significant. Despite Durrrr’s shenanigans and suckouts, it seemed as though he was finally starting to reveal his strength. His style had changed and the tables were turning, the unstoppable momentum of Isildur seemed to have been shattered. At one point Durrrr was within 350k of even, and in that moment many of us who had been disheartened from Durrrr’s loss felt a feeling of relief. This was a moment of comfort in the world of high stakes poker. When I read that Durrrr was almost even, I thought to myself “well, I suppose that’s that. This guy’s run is finally over.” But when I was resigning to my bed, the rest of the online poker world was glued to its monitors. For Isildur, the night was far from over.

What happened next no one at all expected, not even those who were rooting for Isildur. With Durrr having steamrolled back, Isildur, who people were before calling the masked marauder of high stakes poker, seemed to be back to his previous title of a luckbox shot-taking degen. And yet, slowly but surely, Isildur started winning his money back. He won a couple of big pots as soon as Durrrr hit his peak, and from that point Durrrr seemed to not have a chance to protest or get even a word in. The tides had turned, the poker gods had spoken, and Isildur once again seemed to not be able to lose an all-in, winning and winning, and when the score came back to +1.5M for Isildur – he kept going, winning more and more, as if not to leave any doubt in Durrrr’s or anybody else’s mind that his win was no fluke. After that night he was up over 2M, and by the time of my writing this and a couple more sessions later, Isildur is up well over 3M on Durrrr. Since then, he has battled again with Cole and Townsend and stood his ground, and has massacred both Patrik Antonius and David Benyamine. He is now up well over 5M on Full Tilt poker, and is currently fourth on the all time leaderboard on HSDB behind Phil Ivey, Phil Galfond, and Patrik Antonius. He has cemented his name in the annals of online poker as one of the strongest players of all time.

It has been only two weeks since Isildur started playing high stakes on Full Tilt Poker. We truly have witnessed something incredible. But what we – the online poker community – and have not done, is interpreted this event. Made sense of it. Decided what it means. Not just for Durrrr, for Isildur, for high stakes players, or even for railbirds. What does this event mean for online poker? I haven’t the insight to speak for others, but I think that for me, Isildur’s upheaval of the online poker world has caused me to realize and question some things.

The European Hierarchy

It’s important to realize that the online poker world is split into a number of different worlds. Our world is what I will call the Western poker world (the word is poorly chosen but it works well enough). It includes 2p2, Cardplayer, Tableratings, and extends to the major American poker sites – Stars, Full Tilt, and Ultimatebet. The other major world is the Euro poker world, which includes sites like Ipoker, Prima, Party, Betfair, Svenka Spel, and some other sites that are only open to various European players (I don’t know enough about this poker world to mention any other specific sites, forums, etc.). These poker worlds are generally pretty strongly segregated – most of the top players in the Western poker world only play on Western sites, either because they’re American or because the nosebleed action on FTP/Stars runs more regularly. And in the same way, most of the top players in the Euro poker world only play on Eurosites and make most of their money there. But in each poker world there has been established a pecking order – a hierarchy.

From years of poker pros playing each other in different combinations and matchups, people have figured out who is better than who. Over the long run there is not much fluctuation in these hierarchies, as the better players continue to get better and don’t let players lower in the food chain catch up. It is also generally acknowledged that the Western hierarchy is stronger than the Euro hierarchy – the games are tougher and more selective, there are fewer fish, and so the Western hierarchy has bred the best poker players in the world. The Western poker world is tougher, and for that, it is stronger. But Isildur has challenged that. Isildur is from the Euro poker world, and his blitzkrieg against the entire Western poker hierarchy is a direct challenge to this precept. Many Swedish and other European players cheer on the march of Isildur for precisely this reason – to them, Isildur represents their hierarchy taking back control of the poker world. And so Isildur has become, to some, a symbol of the European hierarchy.

The Mythology of Online Poker

 When I saw on that first day that Durrrr was playing Isildur and was down a lot, my feelings were mixed. I think that a lot of people in my situation would think “well, if Durrrr lost to him, then I guess that validates my loss,” and there was probably a dash of that emotion somewhere, but it certainly wasn’t decisive. As with everybody else on the sidelines, I had to decide who to root for. You can’t really stand outside a cage match and just hope it’s a good fight - no matter how objective you claim to be, somebody in the ring is representing you. If that’s not true, then you’re not watching with enough intensity. And if there ever were a poker game that could be considered a cage match, it would be this one.

A lot of people who aren’t initiated into the world of high stakes poker are quick to compare high stakes players to each other, but the world of high stakes poker is more rigidly divided than it might seem. Durrrr exists in an echelon of online poker that I haven’t reached, and probably never will. He plays for amounts of money that, even if I had the bankroll, probably wouldn’t be playing. Not only that, but his courage –  and degeneracy –  are miles above what I could handle. He is truly in another league, and so in a way he is just as distant to me as he is to any of you. Not only that, but I don’t really know Tom, although I know some people who do and I’m sure he’s a good person. But I have no personal reason to root for him.

 And while this is all true, there was something in me that I couldn’t quite explain that was rooting for Durrrr. Well, more than that. I think there was something inside me that deeply needed Durrrr to win. At first I didn’t really bother to think about it, and maybe I accepted the easy explanation that I just wanted to see Isildur lose. But as the scale of the match grew larger and larger, and the impact of Isildur grew greater and greater, I began to realize that Durrrr represented something else to me in this match. He represented more than just a vicarious avenger. In fact, he was more than just Tom Dwan, more than just a single poker player, who one can choose to like or dislike. Durrrr represents something else, something much larger.

To me, Durrrr represents my generation. He represents my hierarchy. He represents the entire empire of the Western poker world.  He is the king, and upon his head rests the crown of Western poker. That crown is more than just a piece of jewelry – it is a justification. He wears the crown upon his head because he is the proof that the Western poker world is great. It is proof that we are wise, that we are powerful, and that we are right to think that we are the best in the world. Durrrr holds all of this upon his head. We have imbued it in him. If nobody else in the world can beat Isildur, and if Isildur fights his way to the throne of our poker world, we know that Durrrr will be waiting for him. Durrrr is our last word. He is our proof that ourpoker works, that our poker is powerful, and that we were right to think that our poker is the epitome of all poker.

But, to me, Durrrr represents even more than that. Because you have to realize that this significance that I just mentioned is not granted to Durrrr because he is Durrrr – it is granted to him because of how much he’s won, because of who he’s beaten, and because of the respect and fear that he has garnered. But somebody else could just as easily have been in his place, someone else who might have had the same winnings and accomplishments. There’s something significant because of who Durrrr is and what he’s about that makes him an especially important symbol.

Durrrr can be dumb. Sometimes he makes mistakes, he tilts, he makes clearly –EV calls and he sticks huge stacks in with rags against the nuts over and over again. Durrrr is often reckless, sometimes emotional, and even at times irrational. Durrrr is fallible. He is imperfect. And yet, somehow he wins. He outplays, he outmaneuvers, and outthinks. He reached the top. He beat everyone. He became the king. He symbolizes the human in all of us, and he bears testament that one does not need to be perfect, unphaseable, untiltable in order to become great.  The juggernauts of online poker can sometimes seem to possess an otherworldly stoicism and mental composure. Durrrr is certainly a titan, but his edges are jagged, just as the rest of us. That’s what Durrrr symbolizes to me. I too am sometimes dumb, sometimes I make tilty calls and chase losses. Durrrr is my validation. 

To me then, Isildur represents something totally alien. He represents the nameless feeling that we all know when we play somebody who we feel that we just cannot beat.  The pre-rational feeling that no matter what we do we cannot win; this force (it does not congeal into a person) will push us down and there is no way to fight back, to go up for air – our only option is to surrender. No matter what cards we are dealt or what flop we see, somehow we end up losing or getting outplayed. To a poker player, there is no feeling as terrifying as losing and not knowing why. When Isildur appeared, nobody knew who he was. Nobody knew why he played the way he did, how he was so good, or why he won so much. He surprised everyone, and in a whirlwind he destroyed almost everybody he played. He was a faceless force who suddenly disrupted all of the sensible hierarchy of the Western poker world. Whether or not we acknowledge it, everybody became afraid. Afraid that maybe he would tear everything down. That all of our hierarchies would be rendered irrelevant. Maybe he was the greatest poker player in the world. But to claim that title, he must answer to the king. To me, that is the symbolism behind the battle between Durrrr and Isildur.

But my perspective is not the only one, and I will not pretend that my interpretation is any more valid than anyone else’s. For some railbirds who have a more disinterested relationship to the poker hierarchy, many probably are enthralled by the march of Isildur because of all of the action and excitement that he stirs up, and I certainly cannot deny that if making things interesting is the only criterion, Isildur takes the cake. Yet others choose to root against Durrrr because to them Durrrr represents the old order, and Isildur, a newcomer overthrowing an empire, empowers some them in relation to the poker hierarchy. Maybe others dislike Durrrr because they think he represents an older and more fortunate generation of poker players, or maybe others see him as everything wrong with the culture of internet poker players. And a great many others root against Durrrr because they support Europe over America. The battle between Durrrr and Isildur means many different things to many observers, which is part of the reason why the match has been followed and commented on so passionately.

The Aftermath

Ultimately, as I’m sure you all know, Durrrr lost. Their battle was grand, awesome, and decisive. Isildur triumphed. Now, as the chroniclers of our age of online poker, it is up to us to interpret what that means. There is a lot that I could say about the nature of variance, the significance of leaderboards and results, and the poverty of information – these are issues that we are all grappling with as both students of this world, and as members of it. What did it really mean that Durrrr was up so much money in online poker? That he had beaten so many people, and seemed to be as good as it was? Was it really ever that significant? Were we all fooled by the randomness? We have all seen the simulations where one or two arbitrary lines bound absurdly high above the lot – was Durrrr just an anomaly, his greatness a blip of chance? Or maybe his loss to Isildur was a fluke, the product of bad play, of overconfidence – maybe we have yet to see what Durrrr is really capable of.

There are many who think that Isildur is now the best HU NLHE player in the world. Part of what made Durrrr so powerful and feared was his image – not just his image within the context of an actual match, but merely the awareness that Durrrr did not to lose to anyone. It might seem like a secondary aspect of his game, but if you believe your opponent is someone awesome, someone who no one else can stand up to, it invests your opponent with a great deal of power. It was with this invincible image that Durrrr ruled high stakes NL, but Isildur has shattered that illusion. At this point, having bested almost everybody who stood up to him, Isildur has assumed an even more powerful image, which will make it even more difficult for someone to overthrow him. There are some who’d say that Isildur has proven himself as the new king of online poker.

Or perhaps it is Isildur who is the anomaly, and as fantastically as he entered this world, he will supernova when he leaves it. Since the time I began writing this article, Isildur has lost 2.5M to Patrik Antonius in PLO, cutting his winnings on FTP in half. The significance of this event is certainly smaller than Isildur’s prolonged battle with Durrrr, but nevertheless the tides are rolling in, and the poker gods are plotting their next spectacle. Is this heralding the fall of Isildur, or is this merely the beginning of another battle? The world of online poker is shifting rapidly and much has yet to be seen. I cannot answer any of the questions I have posed, but I hope that you will all consider them as you continue to observe the path that the world of online poker takes from here.

Durrrr and Isildur.

Goddamn, were they meant for each other.

Until next time,

Haseeb, aka Dogishead

Subscribe to this feed

Add to Favorites

Send to Friend

Unlambda: Your Functional Programming Language Nightmares Come True

Table of contents

• What's New in Unlambda World?
• Introduction
  • What is Unlambda?
  • What does Unlambda look like?
  • What are the principles of Unlambda?
  • Links and meta-links to other obfuscated programming languages
• Tutorial
  • Functions and application
  • Combinators
  • Abstraction elimination
    • Making abstraction elimination more efficient
  • More Unlambda builtins
    • v
    • .x
    • d
    • c
  • HOWTO: various programming techniques
    • How do I write a loop in Unlambda?
    • How can I represent numbers in Unlambda?
    • How can I represent lists (and related data structures) in Unlambda?
    • How do I write tests and booleans in Unlambda?
• A note about the Unlambda Quine Contest
• Implementing Unlambda
  • First-class functions
  • First-class continuations
  • Garbage collection
  • Promises
  • Can Unlambda be compiled?
• Unlambda reference
• Unlambda distribution (download Unlambda here)
• Comprehensive Unlambda Archive Network

What's New in Unlambda World?

(If you don't know what Unlambda is, skip this section and move directly to the introduction below.)

[2001/08] This page is being revised in preparation of the Unlambda 3 distribution.

Introduction

“It's disgusting — it's revolting — we love it.” CyberTabloid

“Unlambda, the language in which every program is an IOUCC.” Encyclopædia Internetica

“The worst thing to befall us since Intercal.” Computer Languages Today

“The effect of reading an Unlambda program is like habing your brains smashed out by a Lisp sexp wrapped around an ENIAC. You won't find anything like it west of Alpha Centauri.” The Hitch-Hacker's Guide to Programming

What is Unlambda?

Unlambda is a programming language. Nothing remarkable there. The originality of Unlambda is that it stands as the unexpected intersection of two marginal families of languages:

• Obfuscated programming languages, of which the canonical representative is Intercal. This means that the language was deliberately built to make programming painful and difficult (i.e. fun and challenging).
• Functional programming languages, of which the canonical representative is Scheme (a Lisp dialect). This means that the basic object manipulated by the language (and indeed the only one as far as Unlambda is concerned) is the function.

Obfuscated programming languages (see below for links) are typically made nasty by either strongly restricting the set of allowed operations in the language, or making them very different from what programmers are used to, or both. (Of course, the goal is to do that while still being Turing-complete.) Unlambda does this (note, however, that the operations permitted were not chosen at random: they have their theoretical importance). But whereas most obfuscated programming languages try to somehow model the Turing Machine paradigm, Unlambda does not use a tape, array or stack. Nor is it binary-oriented; as a matter of fact, it does not manipulate integers in any way. Other remarkable (un)features of Unlambda are the fact that it does not have any variables, data structures or code constructs (such as loops, conditionals and such like).

Rather, Unlambda uses a functional approach to programming: the only form of objects it manipulates are functions. Each function takes a function as argument and returns a function. Apart from a binary “apply” operation, Unlambda provides several builtin functions (the most important ones being the K and S combinators). User-defined functions can be created, but not saved or named, because Unlambda does not have any variables.

Despite all these apparently unsurmountable limitations, Unlambda is fully Turing-equivalent.

Mathematically, the core of the language can be described as an implementation of the lambda-calculus without the lambda operation, relying entirely on the K and S combinators. Hence the name “Unlambda”. It uses head (“eager”, “by value”, “strict”) evaluation. I cannot claim originality there. However, as far as I know, I am the first to have taken this theoretical concept and made it into an actual (deliberately obfuscated) programming language. I added a couple of functions (chosen for their obscurity) to the language so as to make output (and, in version 2, input) possible, or just to make things even more obscure (delay and call/cc are such).

A note on terminology: The phrase “purely functional programming language” is usually applied to languages, like Haskell or Clean, which are lazy and demand explicit sequencing of side effects. I dislike this terminology: for one thing, a “functional” programming language is one in which functions have first-class citizenship, so a “purely functional” one should be one where, as in Unlambda, only functions have first-class citizenship. And what are usually called “purely functional programming languages” should be called, exactly as I just did, lazily evaluating programming languages with explicitly sequenced side effects. All these points are orthogonal: it is quite possible to conceive a lazy programming language which is not functional, or an eager (i.e. non-lazy) functional programming language which still demands explicit sequencing of side effects. In any case, this is to say that I might, on occasion, speak of Unlambda as a “purely functional” programming language, although, with the usual terminology, it is not.

What does Unlambda look like?

Well, let's discuss an example: the following Unlambda program calculates and prints the Fibonacci numbers (as lines of asterisks)

```s``s``sii`ki
  `k.*``s``s`ks
 ``s`k`s`ks``s``s`ks``s`k`s`kr``s`k`sikk
  `k``s`ksk

(All whitespace is optional and arbitrary. Some former versions of this page gave a uselessly complicated and inefficient program.)

You're right: it's not very readable. Writing Unlambda programs isn't really as hard as it might seem; however, reading Unlambda programs is practically impossible. We'll be explaining what all this means later on, but let's just stick to basic observations for the moment.

As you can see, the most common character (essentially, it makes up half of any Unlambda program) is the backquote (ASCII number 96=0x60). The backquote represents Unlambda's apply operation. After that come the S and K combinators (and I, but I can be done away with entirely). Some other characters can occur in Unlambda programs but they are not nearly so common. Besides the backquote and the letters s, k and i, the above program has r and .* as its only other building blocks: these are the Unlambda printing functions (r prints a newline and .* prints an asterisk). The more sophisticated Unlambda functions (v, d, c, e and the input functions) are not used here at all.

What are the principles of Unlambda?

The number one principle of the Unlambda language is that everything is a function: this is true in the sense that Unlambda is a profile of the pure untyped lambda calculus. (Well, to be honest, the d builtin isn't precisely a function, but we will consider it as such anyway.)

Despite Unlambda being a form of the lambda calculus, it does not have a lambda (abstraction) operation. Rather, this operation must be replaced by the use of the S, K and I combinators — this can be done mechanically using abstraction elimination. Because there is no abstraction, functions are not named in Unlambda (except the builtin ones): there are no variables or such thing. This doesn't mean you can't build up your own functions. Nor does the fact that there are only functions in Unlambda prevent you from coming up with data structures and the like, but you just have to represent them with ad hoc functions. In fact, you can so well build your own structures and such that Unlambda is (and, to work, must be) garbage-collected like any decent high-level language.

So, everything is a function. To start with, you have the builtin functions (i, k, s and the like), and you can do one thing: apply a function F to a function G, the result being denoted `FG. It is from this basic idea that Unlambda is built.

Links and meta-links to other obfuscated programming languages

• The Random Programming Languages List, by Ben Olmstead (also the inventor of Malbolge, probably the most devilish language in existence), is a quite comprehensive list of evil programming languages. It mentions Unlambda.
• The Turing Tarpit, by Brian Connors (named after an entry in the Jargon File), is a similar list of Bad Languages and other cyberlinguistic horrors. It also mentions Unlambda.
• Ryan Kusnery's list of Weird Programming Languages is also quite good, despite its not mentioning Unlambda.
• Prfnoff's Obfuscated Languages list mentions two languages he wrote (not usually included in similar lists): Fromage and BAK.
• Eric S. Raymond's famous Retrocomputing Museum lists a few thinks that cause a feeling “between nostalgia and nausea”.
• Intercal remains the archetype of the Obfuscated Programming Language.
• Cats-Eye Technologies (used to be http://www.cats-eye.com/ and has moved to http://www.catseye.mb.ca/: thanks to Rafael Kaufmann for pointing this out) hosts a lot of items of related interest, including the famous BrainF*** language, whose name quite appropriately describes the point of all these languages. They also have a page on fortune's lesser-known programming languages.
• The “Institute of Applied Iconoclasm” maintains an Esoteric Languages Database, which lists Unlambda. They also seem to have a very high opinion of it, and of myself ;-)
• The Esoteric Programming Languages Ring of which this site is part:
  [ Previous 5 Sites | Previous | Next | Next 5 Sites | Random Site | List Sites ]

Tutorial

Although the very idea of a tutorial for such an obfuscated language as Unlambda is patently absurd, I shall try to give a brief introduction to the concepts before dwelling in the details of the reference section (which is also very short considering how small Unlambda is as a whole).

Functions and application

As has been mentioned in the introduction, the only objects that the Unlambda programming language manipulates are functions. Every function takes exactly one argument (that is also a function) and returns one value (that is also a function).

The basic building blocks for Unlambda programs are the primitive functions and the application operation. There are seven primitive functions in Unlambda version 1: k, s, i, v, d, c and .x (where x is an arbitrary characters — so actually that makes 6+256 primitive functions, but we shall consider .x as a single function; the r function is but a commodity synonym for .x where x is the newline character). Unlambda version 2 adds the following new primitive functions: e, @, ?x (where x is a character) and |.

Function application is designated with the backquote (ASCII number 96=0x60) character. The notation is prefix, in other words, `FG means F applied to G.

We'll be explaining in detail what application means exactly, but for the moment, we'll just say that it means that F will do something with the value of G, including applying other functions to it, or applying it to other functions. (That's about the only thing it can do, as a matter of fact.) Just how F does this will become clear later on (or it should). We have to note, of course, that both F and G may themselves be obtained by applying various functions to each other.

The fact that every Unlambda function is unary (takes exactly one argument) means that the backquote notation is unambiguous, and we do not need parentheses (or, if you prefer, the backquote plays the role of the open parenthesis of Lisp, but the closed parenthesis is unnecessary). For example, ``FGH means (F applied to G) applied to H whereas `F`GH means F applied to (G applied to H). To check whether an expression is a valid Unlambda expression, there is a simple criterion: start at the left with a counter equal to the number 1, and move from left to right: for every backquote encountered, increment the counter, and for every primitive function encountered, decrement it; the counter must always remain positive except at the very end when it must reach zero.

Since all Unlambda functions take exactly one argument, when we wish to handle a function of several arguments, it is necessary to “curry” that function. That is, read the arguments one after another. For example, if F is a function that should take three variables, it will be applied thus: ```FG1G2G3. The idea being that F will do nothing but read the first argument and return (without side effects) a function that reads the second argument and returns a function that reads the third argument and finally do whatever calculation it is F was supposed to perform. Thus, both ``FG1G2 and `FG1 are legal, but they don't do much except wait for more arguments to come.

The previous discussion is not so theoretical. Of course, when the user is defining his own functions, he may use whatever mechanism he seems fit for reading the functions' arguments (but such a currying is certainly the best because pairs and lists are so horribly difficult to define in Unlambda). But the builtin k and s functions take respectively 2 and 3 arguments, and the several arguments are passed in the manner which we have just described. (As a side note, I remark that it is, if not impossible, at least inconvenient, to construct functions that take zero arguments because preventing evaluation until all arguments have been read is good but when there are no arguments to be read, the situation is not pleasant; in the pure lambda calculus there is no problem because evaluation order is unspecified and irrelevant, but in Unlambda we have a bigger problem. Here the d function might help.)

A note about evaluation order: when Unlambda is evaluating an expression `FG, it evaluates F first, and then G (the exception being when F evaluates to d), and then applies F to G. Evaluation is idempotent: that is, evaluating an already evaluated expression in Unlambda does not have any effect (there is no level-of-quotation concept as in m4 or SIMPLE).

(Perhaps it would be clearer to describe things by distinguishing expressions and functions, where the latter are obtained by evaluating the former. This is what the Java version of the Unlambda interpreter does, for example (whereas the Scheme version does not). It is merely a matter of choice. True, the distinction might help in understanding the d builtin, since it keeps an expression in its unevaluated form.)

We now turn to the description of the Unlambda builtins.

Combinators

The k and s builtins are the core of the language. Just these two suffice to make Unlambda Turing complete (although .x is also necessary if you want to print anything). The k builtin is easy enough to describe: it takes two arguments (in curried fashion, as explained above) and returns the first. Thus, ``kXY evaluates to X (evaluated). Note that Y is still evaluated in the process. The s builtin is slightly more delicate. It takes three arguments, X, Y and Z, and evaluates as does ``XZ`YZ.

So, let's get things straight: k doesn't do much until it is applied to two arguments, in which case it throws the second one away and returns the first. As for s, it doesn't do much until it is applied to three arguments, at which point it applies the first to the third, and the second to the third, and the result of the former application to the result of the latter.

To take an example, consider ```skss: here s is applied to three arguments, k, s and s, so it performs the evaluation of ``ks`ss. But here we see that the first k is applied to two arguments (s and `ss), so that it returns the first (namely s), and the final result is s.

We also mention immediately the i function: it is simply the identity function In other words, it takes an argument and returns it intact. The i function is not strictly necessary but it is practical. It could be replaced by ``skk. (Indeed, ```skkX evaluates as ``kX`kX because of the s, which in turn evaluates as X because of the k.)

To summarize, the k builtin is a “constant function constructor”. That is, for all X, `kX is the constant function with value X. The s builtin corresponds to “substituted application”: that is, ``sXY is a function that, instead of applying X to Y directly, will apply each of them to Z (the argument) first, and then one to the other. Finally, i is the identity function.

Abstraction elimination

We will now try to describe the central process of abstraction elimination. This is not necessary to understand how Unlambda works, but it is necessary to understand how you can do anything with it.

The central feature which appears to be missing from Unlambda is that of variables. This is precisely what abstraction elimination enables us to recover. The problem is, given an expression F that contains, apart from ordinary Unlambda symbols, one “variable” symbol which we will write $x, to build a function that, when applied to some X, will return the value of F with X substituted in place of $x. In other words, we want to build a function (which we will write ^xF) which takes a value X for $x and does some operation (specified by F) on it. This is the lambda (or abstraction) operation of the lambda calculus (our notation ^ is supposed to stand for a lambda). Unfortunately, Unlambda, as its name indicates, does not have this lambda operation, and our problem is to eliminate it, in a systematic way, from expressions (hence the name abstraction elimination). For example, ^x$x (the function of $x which simply returns $x) is supposed to give i (or something equivalent) when abstraction elimination is performed.

So, we take an expression F involving $x, and we want to eliminate the starting lambda in ^xF. We do this by induction on the complexity of F; there are three cases which must be taken into account: either F is builtin (or some variable other than $x, if we permit this), or F is $x, or F is an application, say, `GH, with G and H simpler expressions (which, by induction, we know how to reduce). So we consider these three cases separately:

• In the first case, we want to eliminate the lambda from ^xF, where F does not depend on $x. So it is the constant function with value F. But, as we know, this is `kF. So we know how to eliminate abstraction in this case.
• In the second case, we want to eliminate the lambda from ^x$x. But this is precisely the identity function, so it reduces as i.
• In the third case, we want to eliminate the lambda from ^x`GH, assuming we know how to eliminate the lambda from ^xG and from ^xH. But the function we are considering takes an X and applies it to ^xG, then to ^xH, and finally applies the result of one to the result of the other. This is precisely the role of the s builtin. So ^x`GH is no other than ``s^xG^xH (and by eliminating the lambda from the inner expressions we get what we wanted).

Finally, abstraction elimination is described mechanically as follows: consider the expression F and we want to eliminate the lambda from ^xF. Scan the F expression from left to right: for every ` (backquote) encountered, write ``s (by virtue of the third case above); for every $x encountered, write i (by virtue of the second case); and for any builtin or any variable other than $x, write `k followed by the thing in question.

As an example, the function ^x`$xk, which takes a function and applies that function to the function k, transforms as ``si`kk.

If several lambdas need to be eliminated from one expression, the trick is to start with the innermost ones, and to eliminate the outermost lambdas last. As an example, ^x^y`$y$x becomes first ^x``si`k$x (upon eliminating the innermorst lambda) and then ``s``s`ks`ki``s`kki (upon eliminating the outermost).

If several lambdas are present, i.e. if several abstraction eliminations are performed as explained in the previous paragraph, the length of the resulting expression grows exponentially (with factor 3 for each lambda). A single ` becomes ``s after one abstraction elimination, then ``s``s`ks after a second, ``s``s`ks``s``s`ks``s`kk`ks after a third, ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kk`ks after a fourth. Similar giveaway sequences appear before any builtin.

Making abstraction elimination more efficient

It is sometimes desirable to obtain a shorter result when performing lambda elimination. Shortcuts can be used, but they demand some care.

Consider the first case we described above. We explained that when F is a builtin or a variable other than $x then we can eliminate the lambda from ^xF by simply rewriting it as `kF. This is quite correct. However, this rule applies a bit more widely than we have suggested: this is true as long as F does not involve x, because it is then a constant, and creating constants is precisely what the K builtin is good at. So if F is a lengthy expression not involving $x, instead of going through the tedious process of eliminating in F, we can shortcut the whole thing and rewrite it as `kF.

There is a danger, however, in so doing. While all this works without glitch in the blessed realm of the pure untyped lambda calculus, i.e. in the absence of side effects (the functions we have seen so far do not create any side effects) and as long as we don't express excessive worries about nontermination, there is a slight difficulty involved when evaluating F causes a side effect or might not terminate. Indeed, when we write ^xF, we probably expect the side effect (or nontermination) in question to be delayed until the function is applied (i.e. until $x receives a value, even if that value is ignored); this is indeed the case if we perform abstraction elimination through the canonical (long) way. If, however, we short-cut and rewrite this as `kF, then F is evaluated as soon as this expression is encountered, even if the function is not applied to anything. This might not be what you wanted.

So the shortcut is really this: you can rewrite ^xF as `kF provided (a) F does not involve $x. amd (b) you can prove that evaluating F terminates and performs no side effect. One easy way of making sure of (b) is to check that the only applications found in F are of the form: the K builtin applied to one argument, or the S builtin applied to one or two arguments, or the D builtin applied to any expression whatsoever (see below about this).

If F does not involve x but does involve evaluations which might (or do) cause side effects or nontermination, there is still a way to perform abstraction elimination from `kF without peering in the entrails of F. Namely, to use the D builtin described below, and write `d`kF. A true purist, however, does not rely on the D to make his program work.

Another shortcut in abstraction elimination is to spot expressions such as ^x`F$x and to rewrite them as simply F — provided of course the variable $x does not appear in F. This is pretty benign if F is just a builtin other than D, or a variable other than $x. But if F can produce side effects, this presents the same risks as the other shortcut we just described (and you can also get around them by writing `dF).

Note also that the V builtin can always be abstracted to itself. (That is, `kv is functionally identical to v.)

More Unlambda builtins

v

The v function is a kind of “black hole”. It takes an argument, ignores it and returns v. It can be used to swallow any number of arguments.

The v function can be implemented using s, k and i (and hence, using s and k only). Indeed, it can be written using the lambda expression `^h^x`$h$h^h^x`$h$h (which evaluates to ^x of the same thing), and abstraction elimination shows that this is ` ``s``s`kskk ``s``s`kskk (here is an example when some incorrect shortcuts in an abstraction elimination can be disastrous, for example if ` ``s`kk``sii ``s`kk``sii were used instead, as obtained by attempting to reduce ^h^x`$h$h as ^h`k`$h$h).

.x

The .x function is the only way to perform output in Unlambda (note that in Unlambda version 1 there is no way to perform input). This function takes an argument and, like the identity function, returns it unchanged. Only contrary to the identity function it has a side effect, namely to print the character x on the standard output (this writing takes place when .x is applied). Note that while this function is written with two characters, it is still one function; on no account should .x be thought of as something applied to x (and, just to insist, there is no such function as . (dot), only .x (dot x)). The r function is just one instance of the .x function, namely when x is the newline character. Thus, the `ri program has the effect of printing a newline (so would `rv or `rr or `r(anything), but r alone doesn't do it, because here the r function isn't applied: here my note about the impossibility of currying functions of zero arguments should become clearer).

d

The d function is an exception to the normal rules of evaluation (hence it should be called a special form rather than a function). When Unlambda is evaluating `FG and F evaluates to d (for example when F is d) then G is not evaluated. The result `dG is a promise to evaluate G: that is, G is kept unevaluated until the promise is itself applied to an expression H. When that happens, G is finally evaluated (after H is), and it is applied to H. This is called forcing the promise.

For example, `d`ri does nothing (and remains unevaluated), and ``d`rii prints a blank line (because we are forcing the promise). Another point to note is that ``dd`ri prints a blank line: indeed, `dd is first evaluated, and since it is not the d function (instead, it is a promise to evaluate d), it does not prevent the `ri expression from being evaluated (to i, with the side effect of printing a newline), so that when finally d is applied, it is already too late to prevent the newline from being printed; to summarize, the d function can delay the d function itself. On the other hand, ``id`ri does not print a blank line (because `id does evaluate to d). Similarly, ```s`kdri is first transformed to ```kdi`ri, in which ``kdi is evaluated to d, which then prevents `ri from being evaluated so no newline gets printed.

Writing `d`kF is another form of promise (perhaps more customary but at the same time less transparent): when it is applied to an arbitrary argument Y, then Y is ignored and F is evaluated and returned. This possibility has already been mentioned in the discussion on shortcuts during abstraction elimination.

c

The c (“call with current continuation”) function is probably the most difficult to explain (if you are familiar with the corresponding function in Scheme, it will help a lot). I suggest you try reading the call/cc page at this point. c called with an argument F will apply F to the current continuation. The current continuation is a special function which, when it is applied to X, has the effect of making c return immediately the value X. In other words, c can return in two ways: if F applied to the continuation evaluates normally, then its return value is that of c; but if F calls the continuation at some point, c will immediately return the value passed to the continuation.

Note that the continuation can even escape from the c call, in which case calling it will have the effect of going “back in time” to that c call and making it return whatever value was passed to the continuation. For a more detailed discussion, see any book on Scheme or the call/cc page mentioned.

Examples of c include ``cir: here, `ci evaluates to the continuation of the c which we shall write <cont>, and we have `<cont>r: here, the continuation is applied, so it makes the c call return r, and we are left with `rr which prints a newline. Another interesting example is `c``s`kr``si`ki: in this expression, the argument ``s`kr``si`ki (which does not evaluate any further) is applied to the continuation of the c, giving ```s`kr``si`ki<cont> (where we have written <cont> for the continuation in question); this gives ` ``kr<cont> ```si`ki<cont> which evaluates to `r``i<cont>``ki<cont>, hence to `r`<cont>i (this was where we wanted to get), and in this expression, the continuation is applied, so that the c in the initial expression immediately returns i, and the remaining calculations are lost (in particular, the r is lost and no newline gets printed).

Expressions including c function calls tend to be hopelessly difficult to track down. This was, of course, the reason for including it in the language in the first place.

As an exercice in using c, you might try constructing an expression that when applied to v returns i, and when applied to i returns v (this is not possible in the absence of c). Answer is in the HOWTO section on booleans.

HOWTO: various programming techniques

How do I write a loop in Unlambda?

We'll explain this with a simple example: how to write a loop that prints “Hello, world!” over and over, followed by a certain number of asterisks, each line having one more asterisk than the previous.

The first step is to write the loop using tail-recursion. We want to write a function <loop>: it will take as its argument a function $f that prints a certain number of asterisks, it will print “Hello, world!”, followed by the asterisks, and a newline, and then it will call itself with a new function that prints one more asterisk.

To get things straight, we assume that <msg> is a function that acts like the identity with the side-effect of printing “Hello, world!”, and we assume that similarly, $f acts like the identity with the side effect of printing the asterisks. Moreover, we will write a function <inc> that takes such an $f and returns a new one that prints one more asterisk.

Our first attempt at writing <loop> is the following: ^f``r`$f`<msg><loop>`<inc>$f. The main ideas are: first, to “increase” $f, we simply call the same function again with `<inc>$f as argument (this is the standard use of tail-recursion to avoid imperative constructions like variable change). Second, to make sure we have the side effects of writing the message, the asterisks and the newline, we apply them to the operator (we could have equally well applied them to the operand), which works since they act like the identity.

Only one thing is wrong with our attempt: <loop> cannot be part of its own expansion. Here is how we get around this: we add one more parameter, $h, to <loop>, and we decide that <loop> will be called with this parameter equal to <loop> itself. Now there is no difficulty in writing the loop: it is ^h^f```r`$f`<msg>$h$h`<inc>$f. Eliminating abstraction, we find <loop> equal to ``s``s`ks``s``s`ks``s`k`s`kr``s`k`si``s`kd``s`kk<msg>k`k<inc> and it remains to write the <msg> and <inc> functions. We obtain them by eliminating abstraction respectively from ^x`````````````.H.e.l.l.o.,. .w.o.r.l.d.!$x and ^f^x`$f`.*$x.

Finally, to start our program, we apply to <loop> the function ^h``$h$hi (i.e. ``s``sii`ki), and our final program is

```s``sii`ki
 ``s``s`ks
     ``s``s`ks``s`k`s`kr
               ``s`k`si``s`k`s`k
                               `d````````````.H.e.l.l.o.,. .w.o.r.l.d.!
                        k
      k
  `k``s``s`ksk`k.*

(Concerning indentation: the idea is that, if we insert a line break between an expression F and an expression G to which F is applied, then we start G on the same column as F; furthermore, we then always insert a line break after G.)

How can I represent numbers in Unlambda?

There are many ways to do that. In the previous example, we have (implicitly) represented the integer n by the function that acts like the identity but with the side effect of printing n asterisks. Such a representation is fine for adding integers (just compose the functions, i.e. the addition function is ^m^n^x`$m`$n$x), but you won't be able to multiply them for example.

Generalizing a little we can arive at a representation of integers which is quite standard and which allows any kind of manipulation (i.e. any recursive function on the integers can be represented in the pure lambda calculus using this representation), the so-called “Church integers” (named after Alonzo Church, the inventor of the lambda calculus). Our previous representation represented n as the n-th iterate of the function .*: this is not good because we can't do much with .*. Rather to try to find a function which is general enough to permit arbitrary manipulations (it can be found but it is a bit long), we represent n as the n-th iterate of a parameter function $f. So we write

• <0> is ^f^x$x (i.e. `ki).
• <1> is ^f^x`$f$x (i.e. i).
• <2> is ^f^x`$f`$f$x (i.e. ``s``s`kski).
• <3> is ^f^x`$f`$f`$f$x (i.e. ``s``s`ksk``s``s`kski).
• and so on…

Using this representation, the various operations are quite simple to perform on numbers:

• The function <print> which prints a Church integer as a line of asterisks is ^n`r``$n.*i, i.e. ``s`kr``s``si`k.*`ki.
• The function <inc> which increments a Church integer is ^n^f^x`$f``$n$f$x, i.e. `s``s`ksk (this is a very highly optimized abstraction elimination).
• The function <add> which adds two Church integers is ^m`$m<inc>, i.e. ``si`k`s``s`ksk.
• The function <mul> which multiplies two Church integers (by applying them consecutively to the same function) is ^m^n^f`$m`$n$f, i.e. ``s`ksk.
• The function <pow> which raises its second argument to the power of its first, by applying the first argument to the second (thus multiplying it with itself as many times as given by the first) is ^m^n`$m$n, i.e. i (impressive, isn't it?).

As an example of the use of Church integers, we construct an Unlambda program that prints a line of 1729 stars. To do this, we use the fact that 1729 is the sum of 10³ and 9³ (Srinivasa Ramanujan in memoriam), so we write the program as `<print>`^n``<add>`<3>$n`<3>`<inc>$n`<2><3>, (we have used the fact that 9 is 3² and 10 is its successor), so `<print>```s``s`k<add><3>``s`k<3><inc>`<2><3> and after replacement our program is finally

```s`kr``s``si`k.*`ki
 ```s``s`k``si`k`s``s`ksk``s``s`ksk``s``s`kski
   ``s`k``s``s`ksk``s``s`kski`s``s`ksk
  ```s``s`kski``s``s`ksk``s``s`kski

How about comparing the Church integers? Sure enough, that can be done. I suggest the following — however, keep in mind that their performance (both in size and time) is far worse than the previous functions, and they are on the whole far less “polished”.

• The function <test> which returns i if its argument is nonzero, and v otherwise, is ^n``$n`kiv, i.e. ``s``si`k`kiv. A faster (but longer) version of the same uses call/cc to return immediately when the argument has been discovered to be non-zero: ^n`c^q`v``$n$qi, i.e. ``s`kc``s`k`sv``ss`k`ki.
• The function <leq> which returns i if its first argument is less or equal to its second, and v othwerise, is ^m^n```$m<A>^ti``$n<A>^tv where <A> is ^f^g`$g$f (I suggest working this out to understand the modus operandi); so <leq> is ``s``s`ks``s`kk``s``si`k``s`k`sik`k`ki`k``s``si`k``s`k`sikv.

To decrement (and hence to substract) Church integers is by no means impossible. I don't know if it can be done with even moderate efficiency, however. The following scheme will work, but it is hopeless algorithmically:

• Consider ``$ni`ki: it evaluates to `ki for any Church integer $n, and, if $n is `k`kk, then it evaluates to k. Consequently, ^n````$ni`ki`ki`<inc>$n returns `<inc>$n if applied to an argument $n which is a Church integer, and `ki (i.e. the Church integer <0>) if applied to `k`kk. Call this function <_inc>. It is ``s``s``s``si`ki`k`ki`k`ki`s``s`ksk.
• Consequently, the function <dec>, which decrements a Church integer, can be written as ^n``$n<_inc>`k`kk, i.e. ``s``si`k``s``s``s``si`ki`k`ki`k`ki`s``s`ksk`k`k`kk. Note that this function takes <0> (i.e. `ki) to `k`kk) — so you should only use it on Church integers which were <test>ed as non zero.
• The substraction function can be built from the <dec> function. I won't even write it because it's too ugly.

Note that the Church integers are by no means the only way to represent integers in Unlambda. Essentially, there are two paths: you can either use a representation which is particular to your problem at hand (as we did above) and which is not completely general, or you can use a universal representation, i.e. one which can be transformed into the Church integers and vice versa (and which differs only by questions of convenience). An example of a non-universal representation is: representing n by a function that prints n asterisks. An example of a universal representation is: representing n by a list of length n, or representing n by a function which evaluates its argument applied to i n times.

How can I represent lists (and related data structures) in Unlambda?

We discuss how to create two types: products (i.e. pairs) and unions.

To create products we represent the pair of $u and $v as a function which is capable, on demand, of producing one or the other variable:

• The <cons> function (creates a pair from its two arguments) is ^u^v^f``$f$u$v, i.e. ``s``s`ks``s`kk``s`ks``s`k`sik`kk.
• The <car> function (returns the pair's first element) is ^p`$pk, i.e. ``si`kk.
• The <cdr> function (returns the pair's second element) is ^p`$p`ki, i.e. ``si`k`ki.

A union type is one which is capable of retaining one of two cases, with one datum in each case, and distinguish the two cases. It is dual to a product type:

• The <q1> function (creates a union in the first case) is ^u^f^g`$f$u, i.e. ``s`k`s`kk``s`k`sik.
• The <q2> function (creates a union in the second case) is ^v^f^g`$g$v, i.e. ``s`kk``s`k`sik.
• The <switch> function (takes a union and two functions and applies the first one to the union's data in the first case, the second one in the second case) is ^q^f^g``$q$f$g, i.e. i.

What you can do with these types is up to your imagination. A list might be created as a chain of pairs, for example. There is a little difficulty at the end of the list (to represent the empty list, that is). The obvious way around it is to represent a list by a union type, where the first case represents the empty list and the second case represents a pair of the first element and the rest of the list. This works but it is long. Another solution is use v for the empty list: this is more practical for some operations (essentially, because it is shorter), and less for others (essentially because v is a bit tricky to detect, and requires call/cc for that).

How do I write tests and booleans in Unlambda?

A pair of boolean values is a pair of Unlambda functions used (arbitrarily) to represent “true” and “false”. The essential thing is that they be universal, i.e. there should exist an <ifthenelse> function which takes three arguments: if the first is the boolean <true> then it returns the second, if the first is the boolean <false> then it returns the third.

Many pairs of functions can be used to represent booleans. Here are a few suggestions:

• i and v: this choice is the “standard” (or “internal”) Unlambda choice of booleans (because it is used by the input functions, and because the functions are already part of the language). They have some advantages, for example then <and> function is very easy to write (it is ^p^q`$p$q, hence i). They are frequently useful in the case where $f is a function which performs some side effects (when passed an argument $x, say): if you want to make the side effects happen according to the value of a boolean $b, just replace `$f$x by ``$b$f$x. However, because v is difficult to test, the <ifthenelse> function is a bit complex: it is ^b`c^q``k`ki``$b$qk, i.e. ``s`kc``s`k`s`k`k`ki``ss`k`kk
• k and `ki: this choice is also very standard. The advantage is that the <ifthenelse> function is extremely simple: it is ^b^x^y``$b$x$y, i.e. i (notice how i plays many roles in Unlambda?). The perspicacious reader will observe that, because of this, we build the <ifthenelse> of the other boolean pairs by converting them to this pair.
• ^x^y`$x$y (i.e. i) and ^y^x`$y$x (i.e. ``s`k`sik). Then the <ifthenelse> is ^b``$b`kk`k`ki, i.e. ``s``si`k`kk`k`k`ki.
• i and `ki: these are the two first Church integers. The <ifthenelse> function is then ^b``$b`kk`ki, i.e. ``s``si`k`kk`k`ki.

A note about the Unlambda Quine Contest

Recall that a quine is a program that prints its own listing. By the fixed point theorems in logic, such a program exists in any Turing-complete language in which printing an arbitrary string is possible (by a computable program of the string — a technical criterion which is satisfied in all programming languages in existence). Although the fixed point theorem is constructive (and thus actually algorithmically produces a quine), actually writing down the program can be difficult. See my quine page and my personal collection of quines for examples of quines in (ordinary, non obfuscated) programming languages.

From 1999/10/27 to 1999/11/03, I opened the Unlambda Quine Contest: I had written a quine in Unlambda myself, and I invited anyone else to do so. During that week, the quines were kept secret (only their md5 fingerprint was revealed so that it could be later checked), in order that their independence be guaranteed. I offered a copy of the Wizard Book to the first person to produce a quine (retrospecively I find that I should have offered it to the best quine, or to the shortest one, or some such thing, but no matter).

The contest is now over. Olivier Wittenberg (olivier.wittenberg@ens.fr) won the prize with his one megabyte quine that he sent me within a few hours of the contest's opening. Subsequent quines were written by Panu Kalliokoski (Panu.Kalliokoski@nokia.com), Jean Marot (jean.marot@ens.fr), Denis Auroux (denis.auroux@ens.fr) and Jacob Mandelson (jlm@ghs.com).

All these quines are truly gems (and, once again, I congratulate all the authors). The shortest one is only 491 bytes long, and was written by Jean Marot. The most efficient one (in terms of data/code size ratio) was written by Denis Auroux. Jacob Mandelson's quine is also very remarkable in that it minimizes the number of dots (dots are printing functions in Unlambda) to only 60.

The full list of quines can be found in the quine/ directory on the FTP repository of the Comprehensive Unlambda Archive Network.

I don't have any special remarks to make about how quines can be written in Unlambda. My general quine page already contains everything I have to say about quines; as for the particular case of Unlambda, well, for my part, I used a list representation of the data, but many more subtle and compact representations were found later.

Implementing Unlambda

Writing programs in Unlambda is a good exercice in patience, order and method. It is not fundamentally difficult, being mainly a question of applying abstraction elimination to expressions of the untyped lambda calculus (of course, obtaining these expressions in the first place is not necessarily evident); if you're messy it will turn into a nightmare. Debugging or reading Unlambda programs is just about impossible.

Another problem is to write implementations of the Unlambda language (i.e. interpreters, that is, a program that takes an Unlambda program as input, and executes it). This is a task that demands less caution (an Unlambda interpreter is far easier to debug, or to read if someone else wrote it, than an Unlambda program) but more smartness, especially if the targeted language (the language in which the interpreter is written) is a low-level language like C. For the Unlambda programming language combines the difficulties of its two families: of functional languages as far as writing an interpreter goes and of obfuscated languages as far as writing programs goes. At any rate, Unlambda certainly has some nasty features that make it hard to write an interpreter for; and we now discuss some of these nasty features and how to get around them.

Writing an Unlambda interpreter is certainly pedagogically interesting. I think it can be a good introduction to some important concepts in theoretical computer science, because it presents the major difficulties (the “nasty features” as I called them a minute ago) of high-level language interpreters without some of the technical burden of typing or variable bindings (these are interesting also, but it may be good to postpone learning about them to a later lesson). For my part, I certainly learned a good deal by writing various Unlambda interpreters. Unfortunately, I have neither the place nor the knowledge to go in the details of all the important theoretical concepts, but you will learn a lot by trying to write an Unlambda interpreter yourself.

The first interpreter written was the one in Scheme, which forms the Unlambda 1.0.0 distribution. This interpreter is not really interesting, for one thing because Scheme has so many features it makes it almost trivial to interpret Unlambda in. The Unlambda 2.0.0 distribution, however, includes interpreters in several other languages. I suggest beginners to start with the one in Java. It is only of pedagogical interest (being very inefficient), and I have taken care to put a lot of comments in it, and to write it very cleanly (despite the comments themselves' claim to the contrary).

One question which is yet open, however, is how difficult it is to write an Unlambda interpreter in Unlambda. That more or less combines the two classes of difficulty (writing Unlambda programs and writing Unlambda interpreters). I still think that the first class (the difficulty of writing Unlambda programs) would be the dominant one; for one thing, Unlambda (as Scheme) already has all the necessary bells and whistles (such as a call/cc function) making interpreting Unlambda (relatively) easy.

Basically, any functional language interpreter is centered, as explained in the Wizard Book, on the so-called eval/apply cycle, with two functions, eval and apply, calling each other recursively. Eval takes an expression of the language and evaluates it (i.e. executes it), whereas apply takes a function (already evaluated) and some arguments, and applies the former to the latter. Eval calls on apply to evaluate applications (what in Unlambda we write `FG), and apply calls on eval to evaluate the body of a function (in Unlambda, we can argue that functions don't have bodies, but still, when apply is told, for example, to apply s to three arguments X, Y and Z, it calls eval on ``XZ`YZ).

So, the basic Unlambda interpreter (forgetting about d for the moment), written in a sufficently high-level language is very simple: eval evaluates all the builtins to themselves and calls apply to evaluate applications; in turn, apply makes ``kXY into X and ```sXYZ into ``XZ`YZ (which is again fed to eval). Certain features of Unlambda, or unfeatures of the meta language, will complicate the evaluator.

First-class functions

Unlambda has first-class functions. In my sketchy description above, I've simply omitted the important fact that an Unlambda function can be something like `sX (a “partially applied” s).

If the underlying language (the language in which the interpreter is written, aka the “meta” language) has first-class functions, then the obvious thing is to represent Unlambda functions by functions of the underlying language, in which case the apply function of the interpreter becomes particularly trivial (it is just the apply function of the underlying language). Actually, this is not what has been done in the interpreters that accompany the Unlambda distribution (for one thing, because it was more tempting to make the eval function trivial than the apply function), even in languages where this would have been possible (see the SML/NJ version of the interpreter for a good example of this). But it is something worth thinking on (an Unlambda interpreter in Unlambda would probably use this system).

Rather than using first-class functions of the underlying language to represent first-class functions in Unlambda, we can represent them using data structures: represent `kX as a function k1 with a hidden parameter X: applying k yields k1, and applying k1 yields the hidden parameter. These hidden parameters are what would correspond, if we were interpreting a real high-level (functional) language, to closures (i.e. function environments). It should be noted that these closures can become arbitrarily complex (indeed, they are the only kind of data structures we have in Unlambda), and that they will require some kind of memory management (see below).

Furthermore, if the underlying language (say, CAML) has first-class functions and is tail-recursive, then, even if it does not have first-class continuations, the difficulties we have with implementing the continuations of Unlambda are greatly alleviated. Indeed, we can then rewrite the interpreter in Continuation Passing Style (see below) and represent the (passed) continuations as functions of the underlying language, which get called in a tail-recursive manner.

If the underlying language does not have first-class functions, then they must be emulated by means of data structures (indeed, the only “variable” part in a first-class function is its closure, and that can be represented by a data structure, since the code is always the same). This is more or less clear in the Java version of the Unlambda interpreter (Java does not have first-class functions, so we use classes and methods instead, as we are supposed to).

First-class continuations

Continuations are the major pain for implementing Unlambda when the underlying language does not have them. I refer to my call/cc page (hoping for it to be finished some day) for a more detailed discussion on first-class continuations.

Essentially, the canonical method is to rewrite the interpreter in Continuation Passing Style. Then eval and apply take one more argument: a continuation, and instead of returning their result, they throw that result to the continuation they were given (the continuation represents the “future of computation” at this point, and it is the continuation which will call the further eval and apply functions as needed).

If the underlying language has first-class continuations, of course, then we do not need CPS, because we can represent the continuations of Unlambda by continuations in the meta language (this is what has been done in the Scheme and SML/NJ versions of the interpreter). If it does not, but at least it has first-class functions and is properly tail-recursive, then we can very easily rewrite the interpreter in CPS, by representing continuations of Unlambda by functions in the meta language (this is what has been done in the Caml version of the interpreter, since Caml has first-class functions but not first-class continuations; it may be instructive to compare the Caml version with the SML/NJ version). In this case, the eval and apply functions each terminate by calling their continuation in tail-recursive manner, so tail-recursion is heavily used.

If the underlying language (or, more precisely, its implementation) is not properly tail-recursive, then we cannot use CPS directly, because CPS calls are tail-recursive, they never terminate (except at the very end of the program), so in a non properly tail-recursive language, this will give a stack overflow (consider, for example, the RCS revision 1.5 of the Unlambda interpreter in Java that is included in the distribution). There are various ways to work around this. I don't know what is “standard”, if anything. One way which I find elegant is to introduce “tasks”: rather than having apply and eval never terminate and finish by calling their continuation, have them return a “task”, which is something like a continuation plus a value about to be thrown to the continuation, and when the task is run, it proceeds with the computation. For details, consider the changes between RCS revisions 1.5 and 1.6 of the interpreter in Java.

[All this discussion does not specifically concern Unlambda. It should be moved to my call/cc page when I find the time.]

If the underlying language has neither first-class continuations nor first-class functions nor proper tail-recursion, as is the case of C, then things are even more messy. All the missing abstraction layers have to be built up from scratch. First-class functions, as noted earlier, have to be replaced by the appropriate data structures, both in the handling of the Unlambda functions themselves, and in the handling of the Unlambda continuations. Yuck.

Garbage collection

As in any language having first-class (higher-order) functions, and, therefore, escaping closures, the lifetime of the various structures is not statically determined in Unlambda, and some kind of automatic memory management (aka “garbage collection”) is necessary. If the underlying language has first-class functions and Unlambda functions are represented by functions of the meta language, then the garbage collection system for the meta language is used in Unlambda as well, and all is transparent. If it does not, data structures must be used to replace the missing functionalities, and these data structures have to be garbage collected. If the underlying language has garbage collection (e.g. Java), then all is for the better, because, there again, we can rest on the existing structures. But if it doesn't, some kind of memory management has to be added to the interpreter. The simplest solution is to use an external garbage collector (for example, the Hans Boehm conservative C/C++ garbage collector, which I used in the C version of the interpreter).

But, as Jacob Mandelson (jlm@ghs.com) pointed out to me (and as he demonstrated in his Unlambda interpreter, full garbage collection is not necessary in Unlambda. Indeed, since the language is without side-effects, and in particular without the possibility of modifying pointers (in the closures) once they are created, new objects can only point to older objects, and cycles cannot be created. Under those circumstances, a simpler memory mangement system will suffice: reference counting (i.e. keeping a count of the number of references to each object, and freeing a pointer when the reference count becomes 0). The interpreter present in the c-refcnt/ directory of the Unlambda distribution uses this reference counting method (and is otherwise identical to the garbage-collected interpreter in the c/ directory).

Promises

Promises (i.e. the use of the d function) make Unlambda a bit more of a mess. Without them, the eval function would be completely straightforward: call eval on the operator, call eval on the operand, and then call apply of the former on the latter. But in fact, the result of the first eval must be checked: if it happens to be d, then the further steps are not performed, the operand is bundled (unevaluated) in a promise, and that promise is returned (e.g. thrown to the continuation) as the result of the computation. Promises are forced in the apply function: when apply receives a promise as operator, it must call eval to force the promise, and to evaluate the part that was left unevaluated, and finally apply it to the operand.

It may, therefore, seem that the apply function will never receive d as operator (it is held back at the level of the eval function). Indeed, if you consider the SML/NJ or Caml versions of the interpreter, that part of the pattern matching is commented out. But there are subtleties: what about something like `cd: the Unlambda specifications clearly state that this evaluate `d<cont>, with <cont> being the appropriate continuation. But instead of constructing the `d<cont> expression and calling eval on it, we may prefer to directly call apply on d and the appropriate continuation, in which case apply will, indeed, receive d as operator. (See the note in the invoke method of the DelContinuation class in the interpreter written in Java.)

Can Unlambda be compiled?

An interesting question, and one whose answer I do not really know, for one thing because I'm not entirely certain as to what “compiling” should mean.

On the one hand, we can certainly write a program (technically, using the snm theorem) that takes an Unlambda program, possibly parses it, and bundles it with an Unlambda interpreter, and call that the “compiled” version. I don't think that qualifies as a compiler: a compiler should turn Unlambda code into code of the target language, not data that will be interpreted by some generic code. Unfortunately, the boundaries between code and data are not as clear as I would like them to be (see also my quine page for more thoughts on the subject). Unlambda can certainly be compiled in Unlambda at least, by the identity function. Jacob Mandelson (jlm@ghs.com) observed that it is more reasonable to try “decompiling” Unlambda than “compiling” it.

If we restrict ourselves to the S, K and I combinators (as well as printing functions), removing the troublesome C and D functions, then Unlambda can be compiled, at least in a high-level functional language (which can then be compiled in low-level imperative languages using standard methods): for example, ```sii``sii (an endless loop) would be trivially compiled, using a lisp-like notation, in (((S I) I) ((S I) I)), where S and I are part of the “Unlambda run-time library”. This may seem like a void assertion, but note the important difference between this and producing (interpret '(((S I) I) ((S I) I))), where only interpret is defined: the former is a true (albeit trivial) compilation, and the latter is merely bundling the program as data with an interpreter to read the data. The c (call/cc) function would not cause considerable trouble either, if the underlying language (the target language for compilation) has first-class continuations, and even if it doesn't, we can emulate them for example by producing CPS code.

Promises are a much bigger problem: I don't think it is possible to compile Unlambda, with the d special form, in a reasonable programming language. Indeed, whereas we could convert “apparent” promises, such as `dX, into promises from the target language, it is not possible to know beforehand whether a piece of code will really be interpreted or merely made into a promise.

On the other hand, promises aren't anything like an eval function (something that canonically can't be compiled — or at any rate, to compile it you need to bundle the program with an entire interpreter or compiler). So maybe it is possible after all, but I'm very uncertain as to the way it should work. I wish I could express myself more clearly.

Unlambda reference

First we must specify that whitespace is ignored in an Unlambda program (wherever it may be, except, naturally, between the period and the character in the .x function name). Comments are also ignored, a comment being anything starting from the # character to the end of the line.

If F and G are two Unlambda expressions, then the expression `FG is also an expression (called the application of F to G). It is evaluated as follows: first, F is evaluated (and its value is a function, since there is no other kind of values in Unlambda); if the value of F is not d, then, G is evaluated, and finally the value of F is applied to the value of G.

To complete the description of Unlambda, we need therefore only specify what happens when F is applied to G, and to do that we consider each possible value of F.

k (“constant generator”)

The k function takes an argument X and returns the function `kX (see below).

`kX (“constant function”)

The `kX function (which is not primitive but obtained by applying the primitive function k to some function X) takes an argument, ignores it and returns X.

s (“substitution”)

The s function takes an argument X and returns the function `sX (see below).

`sX (“substitution first partial”)

The `sX function (which is not primitive but obtained by applying the primitive function s to some function X) takes an argument Y and returns the function ``sXY (see below).

``sXY (“substituted application”)

The ``sXY function (which is not primitive but obtained by applying the primitive function s to two functions X and Y successively) takes an argument Z and returns the evaluation of ``XZ`YZ.

i (“identity”)

The i function takes an argument and returns that argument.

v (“void”)

The v function takes an argument X and returns v itself.

c (“call with current continuation”)

The c function takes an argument X and returns either the evaluation of `X<cont> where <cont> is c's current continuation (see below), or else the value passed to <cont> if the latter was applied (with the effect of making c return immediately).

<cont> (a continuation)

Continuations take an argument and non-locally jump to the point in history when the evaluator was waiting for the corresponding c to return, making that c return that argument.

d (“delay”)

The d function is never truly applied (it is a special form). It only occurs in the form `dF where F is an Unlambda expression (see below).

`dF (“promise”)

The `dF function takes an argument Y and evaluates F, giving a function X, and returns the evaluation of `XY.

.x (“print”) and r (“carriage return”)

The .x function is written using two characters. The first character is a period and the second is any character. Nevertheless, .x is a single function in Unlambda, and x in this expression is merely a character (read during parsing), not a parameter to the function. The r function is exactly equivalent to .(newline). The .x function behaves like the i (identity) function, with the side effect that it prints the character x (to the standard output) when it is applied. The r function also behaves like the identity and prints a newline character.

e (“exit”) only in Unlambda version 2 and greater

The e function takes an argument X. It exits immediately, pretending (if the interpreter cares) that the result of the evaluation of the program is X.

@ (“read”) only in Unlambda version 2 and greater

The @ function takes an argument X. It reads one character from the standard input, making it the “current character” and returns the evaluation of `Xi or of `Xv according as one character has been read successfully or not (for example on EOF).

?x (“compare character read”) only in Unlambda version 2 and greater

The ?x function (where x is a character, as in the .x function) takes an argument X. It returns the evaluation of `Xi or of `Xv according as the current character (the one read by the last application of @) is x or not (if @ has not been applied or if it has encountered an EOF, there is no current character, and x is deemed not to be equal to the current character).

| (“reprint character read”) only in Unlambda version 2 and greater

The | function takes an argument X. It returns the evaluation of `X.x, where x is the current character (the one read by the last application of @) or of `Xv if there is no current character (i.e. if @ has not yet been applied or if it has encountered an EOF).

Unlambda distribution

Unlambda 2.0.0 is now available. You can download it using FTP or using HTTP, but using FTP is preferred if you have the choice. If you want older versions, they are available in this FTP directory.

Unlambda is distributed under the terms of the GNU General Public License, either version 2 of this license, or, at your option, any later version. Since Unlambda is Free Software, it comes with absolutely no warranty: see the GNU General Public License for more details.

(Note that this concerns the distribution. There is no copyright on the language itself: you do not need to ask for my permission to write an Unlambda interpreter, and you are permitted (though by no means encouraged) to write a non-free interpreter. As a matter of fact, there exists at least one non-free Unlambda interpreter, the one written by Jacob Mandelson (jlm@ghs.com), which is far more efficient than the interpreters in the Unlambda distribution.)

This document is included in the Unlambda distribution. You can also find it on the World Wide Web at http://www.eleves.ens.fr:8080/home/madore/programs/unlambda/.

Please send comments and suggestions about Unlambda and its interpreters to david.madore@ens.fr.

Happy hacking!

Comprehensive Unlambda Archive Network

The goal of the Comprehensive Unlambda Archive Network is to gather all the Unlambda programs that are written (provided their authors agree, of course). Since there are very few programs in Unlambda altogether, it is convenient to centralize everything in one place, it will not take too much disk space, and a copy of the archive is included in the Unlambda distribution.

You can find the archive in the directory /pub/madore/unlambda/CUAN/ on the “Quatramaran” FTP site. See the MANIFEST file for a list of the programs in the CUAN. Please drop me a note if you have a program you want to add to the archive.

This site is part of the Esoteric Programming Languages Ring:
[ Previous 5 Sites | Previous | Next | Next 5 Sites | Random Site | List Sites ]

Last modified: $Date: 2003/08/10 22:24:48 $

Richard P. Feynman

I didn't pay much attention to what he said.

But the next day I got a telephone call from a pretty famous lawyer here in Pasadena, Mr. Norris, who was at that time on the State Board of Education. He asked me if I would serve on the State Curriculum Commission, which had to choose the new schoolbooks for the state of California. You see, the state had a law that all of the schoolbooks used by all of the kids in all of the public schools have to be chosen by the State Board of Education, so they have a committee to look over the books and to give them advice on which books to take.

It happened that a lot of the books were on a new method of teaching arithmetic that they called "new math," and since usually the only people to look at the books were schoolteachers or administrators in education, they thought it would be a good idea to have somebody who uses mathematics scientifically, who knows what the end product is and what we're trying to teach it for, to help in the evaluation of the schoolbooks.

I must have had, by this time, a guilty feeling about not cooperating with the government, because I agreed to get on this committee.

Immediately I began getting letters and telephone calls from schoolbook publishers. They said things like, "We're very glad to hear you're on the committee because we really wanted a scientific guy . . ." and "It's wonderful to have a scientist on the committee, because our books are scientifically oriented . . ." But they also said things like, "We'd like to explain to you what our book is about . . ." and "We'll be very glad to help you in any way we can to judge our books . . ." That seemed to me kind of crazy. I'm an objective scientist, and it seemed to me that since the only thing the kids in school are going to get is the books (and the teachers get the teacher's manual, which I would also get), any extra explanation from the company was a distortion. So I didn't want to speak to any of the publishers and always replied, "You don't have to explain; I'm sure the books will speak for themselves."

I represented a certain district, which comprised most of the Los Angeles area except for the city of Los Angeles, which was represented by a very nice lady from the L.A. school system named Mrs. Whitehouse. Mr. Norris suggested that I meet her and find out what the committee did and how it worked.

Mrs. Whitehouse started out telling me about the stuff they were going to talk about in the next meeting (they had already had one meeting; I was appointed late). "They're going to talk about the counting numbers." I didn't know what that was, but it turned out they were what I used to call integers. They had different names for everything, so I had a lot of trouble right from the start.

She told me how the members of the commission normally rated the new schoolbooks. They would get a relatively large number of copies of each book and would give them to various teachers and administrators in their district. Then they would get reports back on what these people thought about the books. Since I didn't know a lot of teachers or administrators, and since I felt that I could, by reading the books myself, make up my mind as to how they looked to me, I chose to read all the books myself. . . .

I was overwhelmed.

"It's all right, Mr. Feynman; we'll get someone to help you read them."

I couldn't figure out how you do that: you either read them or you don't read them. I had a special bookshelf put in my study downstairs (the books took up seventeen feet), and began reading all the books that were going to be discussed in the next meeting. We were going to start out with the elementary schoolbooks.

It was a pretty big job, and I worked all the time at it down in the basement. My wife says that during this period it was like living over a volcano. It would be quiet for a while, but then all of a sudden, "BLLLLLOOOOOOWWWWW!!!!" -- there would be a big explosion from the "volcano" below.

The reason was that the books were so lousy. They were false. They were hurried. They would try to be rigorous, but they would use examples (like automobiles in the street for "sets") which were almost OK, but in which there were always some subtleties. The definitions weren't accurate. Everything was a little bit ambiguous -- they weren't smart enough to understand what was meant by "rigor." They were faking it. They were teaching something they didn't understand, and which was, in fact, useless, at that time, for the child.

I understood what they were trying to do. Many [Americans] thought we were behind the Russians after Sputnik, and some mathematicians were asked to give advice on how to teach math by using some of the rather interesting modern concepts of mathematics. The purpose was to enhance mathematics for the children who found it dull.

I'll give you an example: They would talk about different bases of numbers -- five, six, and so on -- to show the possibilities. That would be interesting for a kid who could understand base ten -- something to entertain his mind. But what they turned it into, in these books, was that every child had to learn another base! And then the usual horror would come: "Translate these numbers, which are written in base seven, to base five." Translating from one base to another is an utterly useless thing. If you can do it, maybe it's entertaining; if you can't do it, forget it. There's no point to it.

Anyhow, I'm looking at all these books, all these books, and none of them has said anything about using arithmetic in science. If there are any examples on the use of arithmetic at all (most of the time it's this abstract new modern nonsense), they are about things like buying stamps.

Finally I come to a book that says, "Mathematics is used in science in many ways. We will give you an example from astronomy, which is the science of stars." I turn the page, and it says, "Red stars have a temperature of four thousand degrees, yellow stars have a temperature of five thousand degrees . . ." -- so far, so good. It continues: "Green stars have a temperature of seven thousand degrees, blue stars have a temperature of ten thousand degrees, and violet stars have a temperature of . . . (some big number)." There are no green or violet stars, but the figures for the others are roughly correct. It's vaguely right -- but already, trouble! That's the way everything was: Everything was written by somebody who didn't know what the hell he was talking about, so it was a little bit wrong, always! And how we are going to teach well by using books written by people who don't quite understand what they're talking about, I cannot understand. I don't know why, but the books are lousy; UNIVERSALLY LOUSY!

Anyway, I'm happy with this book, because it's the first example of applying arithmetic to science. I'm a bit unhappy when I read about the stars' temperatures, but I'm not very unhappy because it's more or less right -- it's just an example of error. Then comes the list of problems. It says, "John and his father go out to look at the stars. John sees two blue stars and a red star. His father sees a green star, a violet star, and two yellow stars. What is the total temperature of the stars seen by John and his father?" -- and I would explode in horror.

My wife would talk about the volcano downstairs. That's only an example: it was perpetually like that. Perpetual absurdity! There's no purpose whatsoever in adding the temperature of two stars. Nobody ever does that except, maybe, to then take the average temperature of the stars, but not to find out the total temperature of all the stars! It was awful! All it was was a game to get you to add, and they didn't understand what they were talking about. It was like reading sentences with a few typographical errors, and then suddenly a whole sentence is written backwards. The mathematics was like that. Just hopeless!

Then I came to my first meeting. The other members had given some kind of ratings to some of the books, and they asked me what my ratings were. My rating was often different from theirs, and they would ask, "Why did you rate that book low?" I would say the trouble with that book was this and this on page so-and-so -- I had my notes.

They discovered that I was kind of a goldmine: I would tell them, in detail, what was good and bad in all the books; I had a reason for every rating.

I would ask them why they had rated this book so high, and they would say, "Let us hear what you thought about such and such a book." I would never find out why they rated anything the way they did. Instead, they kept asking me what I thought.

We came to a certain book, part of a set of three supplementary books published by the same company, and they asked me what I thought about it.

I said, "The book depository didn't send me that book, but the other two were nice."

Someone tried repeating the question: "What do you think about that book?"

"I said they didn't send me that one, so I don't have any judgment on it."

The man from the book depository was there, and he said, "Excuse me; I can explain that. I didn't send it to you because that book hadn't been completed yet. There's a rule that you have to have every entry in by a certain time, and the publisher was a few days late with it. So it was sent to us with just the covers, and it's blank in between. The company sent a note excusing themselves and hoping they could have their set of three books considered, even though the third one would be late."

It turned out that the blank book had a rating by some of the other members! They couldn't believe it was blank, because [the book] had a rating. In fact, the rating for the missing book was a little bit higher than for the two others. The fact that there was nothing in the book had nothing to do with the rating.

I believe the reason for all this is that the system works this way: When you give books all over the place to people, they're busy; they're careless; they think, "Well, a lot of people are reading this book, so it doesn't make any difference." And they put in some kind of number -- some of them, at least; not all of them, but some of them. Then when you receive your reports, you don't know why this particular book has fewer reports than the other books -- that is, perhaps one book has ten, and this one only has six people reporting -- so you average the rating of those who reported; you don't average the ones who didn't report, so you get a reasonable number. This process of averaging all the time misses the fact that there is absolutely nothing between the covers of the book!

I made that theory up because I saw what happened in the curriculum commission: For the blank book, only six out of the ten members were reporting, whereas with the other books, eight or nine out of the ten were reporting. And when they averaged the six, they got as good an average as when they averaged with eight or nine. They were very embarrassed to discover they were giving ratings to that book, and it gave me a little bit more confidence. It turned out the other members of the committee had done a lot of work in giving out the books and collecting reports, and had gone to sessions in which the book publishers would explain the books before they read them; I was the only guy on that commission who read all the books and didn't get any information from the book publishers except what was in the books themselves, the things that would ultimately go to the schools.

This question of trying to figure out whether a book is good or bad by looking at it carefully or by taking the reports of a lot of people who looked at it carelessly is like this famous old problem: Nobody was permitted to see the Emperor of China, and the question was, What is the length of the Emperor of China's nose? To find out, you go all over the country asking people what they think the length of the Emperor of China's nose is, and you average it. And that would be very "accurate" because you averaged so many people. But it's no way to find anything out; when you have a very wide range of people who contribute without looking carefully at it, you don't improve your knowledge of the situation by averaging.

At first we weren't supposed to talk about the cost of the books. We were told how many books we could choose, so we designed a program which used a lot of supplementary books, because all the new textbooks had failures of one kind or another. The most serious failures were in the "new math" books: there were no applications; not enough word problems. There was no talk of selling stamps; instead there was too much talk about commutation and abstract things and not enough translation to situations in the world. What do you do: add, subtract, multiply, or divide? So we suggested some books which had some of that as supplementary -- one or two for each classroom -- in addition to a textbook for each student. We had it all worked out to balance everything, after much discussion.

When we took our recommendations to the Board of Education, they told us they didn't have as much money as they had thought, so we'd have to go over the whole thing and cut out this and that, . . . . When the senate budget committee got to it, the program was emasculated still further. Now it was really lousy! I was asked to appear before the state senators when the issue was being discussed, but I declined: By that time, having argued this stuff so much, I was tired. We had prepared our recommendations for the Board of Education, and I figured it was their job to present it to the state -- which was legally right, but not politically sound. I shouldn't have given up so soon, but to have worked so hard and discussed so much about all these books to make a fairly balanced program, and then to have the whole thing scrapped at the end -- that was discouraging! The whole thing was an unnecessary effort that could have been turned around and done the opposite way: start with the cost of the books, and buy what you can afford.

What finally clinched it, and made me ultimately resign, was that the following year we were going to discuss science books. I thought maybe the science would be different, so I looked at a few of them.

The same thing happened: something would look good at first and then turn out to be horrifying. For example, there was a book that started out with four pictures: first there was a windup toy; then there was an automobile; then there was a boy riding a bicycle; then there was something else. And underneath each picture it said, "What makes it go?"

I thought, "I know what it is: They're going to talk about mechanics, how the springs work inside the toy; about chemistry, how the engine of the automobile works; and biology, about how the muscles work."

It was the kind of thing my father would have talked about: "What makes it go? Everything goes because the sun is shining." And then we would have fun discussing it:

"No, the toy goes because the spring is wound up," I would say. "How did the spring get wound up?" he would ask.

"I wound it up."

"And how did you get moving?"

"From eating."

"And food grows only because the sun is shining. So it's because the sun is shining that all these things are moving." That would get the concept across that motion is simply the transformation of the sun's power.

I turned the page. The answer was, for the wind-up toy, "Energy makes it go." And for the boy on the bicycle, "Energy makes it go." For everything, "Energy makes it go."

Now that doesn't mean anything. Suppose it's "Wakalixes." That's the general principle: "Wakalixes makes it go." There's no knowledge coming in. The child doesn't learn anything; it's just a word!

What they should have done is to look at the wind-up toy, see that there are springs inside, learn about springs, learn about wheels, and never mind "energy." Later on, when the children know something about how the toy actually works, they can discuss the more general principles of energy.

It's also not even true that "energy makes it go," because if it stops, you could say, "energy makes it stop" just as well. What they're talking about is concentrated energy being transformed into more dilute forms, which is a very subtle aspect of energy. Energy is neither increased nor decreased in these examples; it's just changed from one form to another. And when the things stop, the energy is changed into heat, into general chaos.

But that's the way all the books were: They said things that were useless, mixed-up, ambiguous, confusing, and partially incorrect. How anybody can learn science from these books, I don't know, because it's not science.

So when I saw all these horrifying books with the same kind of trouble as the math books had, I saw my volcano process starting again. Since I was exhausted from reading all the math books, and discouraged from its all being a wasted effort, I couldn't face another year of that, and had to resign.

Sometime later I heard that the energy-makes-it-go book was going to be recommended by the curriculum commission to the Board of Education, so I made one last effort. At each meeting of the commission the public was allowed to make comments, so I got up and said why I thought the book was bad.

The man who replaced me on the commission said, "That book was approved by sixty-five engineers at the Such-and-such Aircraft Company!"

I didn't doubt that the company had some pretty good engineers, but to take sixty-five engineers is to take a wide range of ability -- and to necessarily include some pretty poor guys! It was once again the problem of averaging the length of the emperor's nose, or the ratings on a book with nothing between the covers. . . .

I couldn't get through to him, and the book was approved by the board. . . .

Then the question came up, "Will the schools be getting the books at the regular time, or could they, perhaps, get them a little earlier, in time for the coming term?"

One publisher's representative got up and said, "We are happy that you accepted our bid; we can get it out in time for the next term."

A representative of the publisher that lost out was also there, and he got up and said, "Since our bids were submitted based on the later deadline, I think we should have a chance a bid again for the earlier deadline, because we too can meet the earlier deadline."

Mr. Norris, the Pasadena lawyer on the board, asked the guy from the other publisher, "And how much would it cost for us to get your books at the earlier date?"

And he gave a number: It was less!

The first guy got up: "If he changes his bid, I have the right to change my bid!" -- and his bid is still less!

Norris asked, "Well how is that -- we get the books earlier and it's cheaper?"

"Yes," one guy says. "We can use a special offset method we wouldn't normally use . . ." -- some excuse why it came out cheaper. The other guy agreed: "When you do it quicker, it costs less!"

That was really a shock. It ended up two million dollars cheaper. Norris was really incensed by this sudden change.

What happened, of course, was that the uncertainty about the date had opened the possibility that these guys could bid against each other. Normally, when books were supposed to be chosen without taking the cost into consideration, there was no reason to lower the price; the book publishers could put the prices at any place they wanted to. There was no advantage in competing by lowering the price; the way you competed was to impress the members of the curriculum commission.

By the way, whenever our commission had a meeting, there were book publishers entertaining curriculum commission members by taking them to lunch and talking to them about their books. I never went.

It seems obvious now, but I didn't know what was happening the time I got a package of dried fruit and whatnot delivered by Western Union with a message that read, "From our family to yours, Happy Thanksgiving -- The Pamilios."

It was from a family I had never heard of in Long Beach, obviously someone wanting to send this to his friend's family who got the name and address wrong, so I thought I'd better straighten it out. I called up Western Union, got the telephone number of the people who sent the stuff, and I called them.

"Hello, my name is Mr. Feynman. I received a package . . ."

"Oh, hello, Mr. Feynman, this is Pete Pamilio" and he says it in such a friendly way that I think I'm supposed to know who he is! I'm normally such a dunce that I can't remember who anyone is.

So I said, "I'm sorry, Mr. Pamilio, but I don't quite remember who you are . . ."

It turned out he was a representative of one of the publishers whose books I had to judge on the curriculum commission.

"I see. But this could be misunderstood."

"It's only family to family."

"Yes, but I'm judging a book that you're publishing, and maybe someone might misinterpret your kindness!" I knew what was happening, but I made it sound like I was a complete idiot.

Another thing like this happened when one of the publishers sent me a leather briefcase with my name nicely written in gold on it. I gave them the same stuff: "I can't accept it; I'm judging some of the books you're publishing. I don't think you understand that!"

One commissioner, who had been there for the greatest length of time, said, "I never accept the stuff; it makes me very upset. But it just goes on."

But I really missed one opportunity. If I had only thought fast enough, I could have had a very good time on that commission. I got to the hotel in San Francisco in the evening to attend my very first meeting the next day, and I decided to go out to wander in the town and eat something. I came out of the elevator, and sitting on a bench in the hotel lobby were two guys who jumped up and said, "Good evening, Mr. Feynman. Where are you going? Is there something we can show you in San Francisco?" They were from a publishing company, and I didn't want to have anything to do with them.

"I'm going out to eat."

"We can take you out to dinner."

"No, I want to be alone."

"Well, whatever you want, we can help you."

I couldn't resist. I said, "Well, I'm going out to get myself in trouble."

"I think we can help you in that, too."

"No, I think I'll take care of that myself." Then I thought, "What an error! I should have let all that stuff operate and [kept] a diary, so the people of the state of California could find out how far the publishers will go!". . . .

Richard P. Feynman (1918-1988) was one of the premier physicists of the second half of the 20th century. He worked on atomic weapons at Los Alamos during World War 2, then spent several years on the faculty of Cornell University, and then (in 1950) became a professor at the California Institute of Technology. He remained at Caltech for the rest of his career. Feynman worked on the theory of superfluidity, predicted the existence of quarks, and was one of the three men whose contributions to quantum electrodynamics were commemorated by the 1965 Nobel Prize in physics. The two other men were Julian Schwinger and Sin-Itiro Tomonaga.

Editor's postscript

We don't know of any other case in which state functionaries have given high marks to a book whose pages were blank, but all the other follies and outrages described in Feynman's narrative are familiar.

During the past ten years we have studied adoptions operated by state agencies in California and elsewhere, and we have seen -- again and again -- the same practices that Feynman observed in 1964. As a rule, state textbook-adoption proceedings are bureaucratic shams. As a rule, the evaluation committees assembled by state agencies are manifestly unqualified to appraise textbooks or to render any meaningful advice.

Recall Feynman's observation that "usually the only people to look at the books were schoolteachers or administrators in education." That is still true. In a typical case, a state agency creates an evaluation committee that consists of schoolteachers and school-district officials, perhaps augmented by an ordinary citizen or two. Then the agency charges this committee with the task of appraising some number of books in a given subject, even though the committee lacks anyone who possesses expert knowledge of the subject in question. The members of the committee then engage in a silly, scripted ritual, producing collective judgments about books that few (if any) members have actually tried to read -- and they eventually contrive some unexplained, unsupported, collective recommendations, declaring that the books should be accepted for use in schools. They don't write individual reports, so the taxpayers cannot know who did what -- i.e., the taxpayers cannot determine who (if anyone) inspected and endorsed any particular book. No one is responsible for anything.

If a state agency really wanted to obtain legitimate evaluations of textbooks, the agency could achieve this by using a process that is very well known: Send each book to a knowledgeable reviewer who will appraise it, who will write a report to set forth and explain his appraisal, and who will sign his name to his report. This is the process employed by the book-review editors of newspapers, magazines and professional journals throughout the land. It works, and it can be repeated to any desired extent: To obtain several appraisals of a given book, simply send the book to several reviewers.

As a rule, however, state agencies don't want legitimate evaluations of the textbooks that publishers submit for adoption, because the agencies are allied with the publishers. The adoption proceedings staged by these agencies are not designed to help school districts, to protect students, or to serve the interests of taxpayers. Rather, they are designed to serve the interests of the publishers, to generate approvals and certifications for the publishers' books, and to help the publishers sell those books to local schools.

This is why we continue to see, in state after state, the same absurdities that Feynman saw thirty-five years ago. In state after state, the legitimate reviewing of books is shunned. In state after state, incompetent committees engage in group-grope "evaluation" shams which embody the emperor's-nose fallacy -- the nonsensical notion that a question can be answered by averaging a bunch of guesses proffered by people who don't know what they are talking about. In state after state, corrupt proceedings are corrupted further by publishers' "presentations": The publishers send salesmen to describe, explain and promote their books to the evaluation committees, to other state functionaries, and even to members of state boards of education. Feynman refused to hear such pitches, because he held that a book should be able to speak for itself. He was right, of course -- but in many states, evaluation committees are routinely subjected to "presentations" by publishers' pitchmen.

Some state agencies are so strongly allied with publishers that the agencies help the publishers to market their books to unwary school districts. Consider, for example, what goes on in Florida. Each year, the Florida Department of Education issues a document called the Florida Catalog of State Adopted Instructional Materials, which includes many anonymous descriptions of textbooks and other materials that have been approved for use in Florida's public schools. The descriptions actually are advertisements. They are promotional claims written by the companies that sell the materials, but this fact is concealed. Florida school districts are led to believe that the glowing descriptions printed in the Catalog represent appraisals developed by the state's evaluation teams. This matter will be described at greater length in another issue of The Textbook Letter.

In the 1980s, however, the pattern of career choices began to change. Until then, even though business ambitions and management degrees have not been disfavored in our competition, business careers attracted relatively few Rhodes scholars. No one suggested this was an unfit domain; it was simply the rare scholar who went to Wall Street, finance and general business management. Only three American Rhodes scholars in the 1970s (out of 320) went directly into business from Oxford; by the late 1980s the number grew to that many in a year. Recently, more than twice as many went into business in just one year than did in the entire 1970s.

This break in an almost century-old pattern coincided with great increases in occupational earnings differentials, which have continued to grow, seemingly exponentially. It seems quaint, if not unfathomable, that just three decades ago the differentials in earnings -- generally two- to fivefold between business leaders and doctors or lawyers, or five- to tenfold with professors, scientists and public servants -- were often rationalized by Rhodes scholars as reasonable additional compensation to balance the lower standing of business jobs among their peers.

When differentials could become a hundredfold or far more -- and as investment banking and similar firms started to recruit young Rhodes scholars who had degrees in math, physics or even history, English and theology -- the yawning prospective wealth chasm understandably became impossible for many to ignore. Even for a few of those most deeply committed to other, more public-spirited pursuits, the lure of such rewards, especially as they are reasonably attainable for people of such high abilities, became much harder to resist.

So what is the matter with this picture?

Nothing -- if one believes that such differentials are necessary for our economic system to thrive. But do many believe that differentials need be this grotesquely large to motivate and reward people adequately, if not richly? No; they are that large today simply because they can be that large, not because of some virtuous working of the market. This is not Adam Smith's capitalism. Just as Smith decried the inevitable greed and corruption of monopoly, he would surely rail against today's self-serving and closed systems of compensation review.

Similarly, nothing is wrong with this picture if one believes that changed career paths of a few privileged people is not of any larger significance. Never mind that some have gifts that realistically could be expected to lead to world-changing breakthroughs, cures or innovations; to greater respect for politics; or to hundreds of profoundly moved and inspired students.

Or if one believes that the social benefits, macroeconomic included, that can be expected as a collective consequence of radically more remunerative paths taken will be as great or greater than would have followed from those not taken. (Does anyone seriously believe that? Isn't the innovation that the country needs most for continued prosperity likely to come from scientists and engineers?)

Or if one believes the rules and practices of corporate governance are adequate to assure reasonable compensation practices. (Can anyone maintain they do, given the undemocratic ways in which corporate directors are chosen and elected, and the myriad examples of executive compensation perversely related to shareholder return?)

Or if one believes the fabric of our democracy might not be frayed by a steadily widening gap between the very rich and the middle class, a gap that could become as cavernous here as it already has in some of the world's least harmonious and most dispiriting countries.

Or if one believes that 10 or 20 years down those career tracks, when going back to earlier ambitions is rarely possible, those choices will be the ones that have created the greatest happiness for those individuals.

Many thought a silver lining of last year's financial crisis -- or from the populist rage that flared against Wall Street excess and to profits born not from creativity but from leverage -- would be that earnings differentials would return from obscene to merely enormous levels, if not to the very generous multiples that had long been adequate to fuel a vibrant economy. Well, the hyper-bonuses are back -- astonishingly having been made even easier to achieve with taxpayers socializing the downside risks. And the crisis? What crisis?

So how many more of America's young and brightest will ask themselves what kind of chumps they are to give up the chance to earn 100 or 500 times as much as their mentors, their doctors, their favorite professors, their idols and heroes?

The writer is American secretary of the Rhodes Trust and executive vice president of the Aspen Institute.

I also noticed that, by the standards of SF conventions, hacker-run gatherings are, well, primitive. SF fans have a continuous tradition of amateur-run conventions going back sixty years; in that time, they've forgotten more about how to run conventions than hackers have yet had time to learn.

In this document, I try to adapt and summarize some of these techniques for the use of people running Linux and open-source gatherings. If you apply these, I guarantee you'll give the customers a better time and be less stressed-out from running things.