Mob Software

8/8/2019 Mob Software

http://slidepdf.com/reader/full/mob-software 1/32

1

Mob Software: The Erotic Life of Code

An Essay in First Person byRichard P. Gabriel & Ron Goldman

Let’s rock!

I’ve got good news: That way o hacking you like is going to come back instyle.

Over the years I’ve despaired that the ways we’ve created to build sotwarematches less and less well the ways that people work eff ectively. More so,

I’ve grown saddened that we’re not building the range o sotware that we couldbe, that the ull expanse o what computing could do—to enhance human lie, tooster our creativity and mental and physical comort, to liberate us rom isolationrom knowledge, art, literature, and human contact—is let out o our vision. Itseems that high-octane capitalism has acted like an acid or a high heat to curdle

and coagulate our ways o building sotware into islands that limit us.But like survivors, we’ve managed to make these islands homes. We’ve ound

the succulent but bitter ruit that can sustain us, the small encrusted or overurredcreatures we can eat to survive, the slow-moving and muddy streams rom whichwe drink against the urge to spit it out. Being survivors, we can make do withlittle. But how little like lie is such an existence.

So gloomy. Bitter and depressing. Deeply conicted.The way out requires just one thing rom us—a strange, rightul thing—

something slant. It is this: Find a way to fght our ear o death.First, though, the gloom. Feel it.

Maybe there aren’t too many in this audience old enough to recall the earlyattempts at putting capsules and rockets into space. What most people

remember are the many successul launches in the 1960s and ’70s where astro-

nauts frst were launched into space but not into orbit; then there was a serieso orbital ights, then orays near the moon, then a moon landing, and fnallythe boringly routine trips gathering rocks and dust, playing gol and goofng off .This is the way to do engineering, many say. Large teams superbly coordinatedproducing success ater success. Sotware should be like this, they say.



2

But these olks don’t remember these other scenes: One rocket lited upabout a dozen eet, ell over, then accelerated horizontally toward a launch build-ing; another lited up a ew hundred eet and started spinning in a Yeatsian gyrebeore being blown up remotely; others simply exploded somewhere in the sky.

Once I viewed an unnarrated series o these explosions, one ater another innothing less than a ballet o destruction and ailure.

NASA began operation on the frst o October, 1958. Alan B. Shepard Jr.became the frst American in space on the fth o May, 1961, launched on thetip o a Redstone rocket. On the twenty-frst o July, 1961, Gus Grissom becamethe second American in space, also launched by a Redstone rocket. And on thetwentieth o February, 1962, John Glenn became the frst American to orbit theearth, launched by an Atlas rocket.

Up until Alan Shepard’s launch into space, the Redstone rocket had experiencedailures including launchpad and downrange explosions 23 times—the lastailure was 2 months beore Shepard’s ight. My avorite ailure took place onthe twenty-frst o November, 1960, when the Redstone’s engines shut off 1second ater ignition: The rocket lited off a couple o centimeters, and then satdown—with no signifcant damage. Between Alan Shepard’s ight and GusGrissom’s, there was a Redstone ailure.

Atlas rockets experienced 36 ailures beore John Glenn’s ight—one occurredthe day ater Glenn went into orbit.

We like to think we can simply imitate a mature engineering practice and getthe same results. As i a Little League baseball team could watch the New York Yankees and say, “hey, let’s just imitate them—we’ll win all the time!” But successrequires undamentals, and we don’t have them.

The highlights o NASA’s history represent a alse view o even a mature

engineering practice. The early days o major American rocketry were flledwith ailures, some o them disasters. To get to the moon, we needed crashesand endless fddling. Why do we think that sotware practice, still in its inancy,can do better?

Sotware is ull o ailure, and will be until we can learn how truly tobuild it.

Fear o ailure is ear o death. In ear o ailure, we seek order.

The Mob Introduced

The Oxord English Dictionary defnes “mob” this way, among others:

A multitude or aggregation o persons regarded as not individually important.—Oxord English Dictionary, Second Edition, denition 4a, part 2



3

Let me say it plainly: We know how to produce small portions o sotwareusing small development teams—up to 10 or so—but we don’t know how tomake sotware any larger except by accident or by rough trial and error. —Becausethe sotware we’re trying to build is too massive—it is simply too difficult to

plan it all out, and we have no idea how to coordinate the number o people ittakes. Every piece o sotware built requires tremendous attention to detail andendless fddling to get right.

In response to this problem we have clung to ads: structured and object-oriented programming, UML, sotware patterns, and eXtreme Programming.We grasp or mathematics or engineering to come to our rescue—perhapseven the law: By requiring licenses or our developers maybe we can orceimprovement in sotware making.

It just won’t happen—it’s like those rockets: We simply do not know howto get massive sotware off the ground without crashing and endless fddling.But we don’t accept that.

The way out o this predicament is this simple: Set up a airly clear architecturaldirection, produce a decent frst cut at some o the unctionality, let loose thesource code, and then turn it over to a mob.

The Commerce of the Creative Spirit

Ever compare poetry to newspaper articles? Maybe poetry isn’t or everyone,but everyone can see there is a diff erence—in quality, in beauty, in its

appeal to humanity. One is daily news; the other is “news that stays news” (EzraPound, “ABC o Reading”). Poetry is constructed, is it not? In act, aren’t allcreative acts the result o deliberately envisioned, careully planned work bysingle individuals?

This passage by the poet and playwright Harold Pinter is typical o howpoets envision:

The thing germinated and bred itsel. It proceeded according to its own logic.What did I do? I ollowed the indications. I kept a sharp eye on the clues I oundmysel dropping. The writing arranged itsel with no trouble into dramatic terms.The characters sounded in my ears—it was apparent to me what one would say

and what would be the other’s response, at any given point. It was apparent to mewhat they would not, ever, say, whatever one might wish. . . .

When the thing was well cooked I began to orm certain conclusions. The point is, however, that by that time the play was now its own world. It wasdetermined by its own engendering image.

—“The Git,” page 144



4

. . .created by the single individual? Writers learn by workshopping. Every nightacross the country, writers sit in groups o 3 to 20, reading and critiquing eachother’s work. Not only are these proessional writers but amateurs who simply wantto improve their diaries. Steven Levy said this in “Hackers”:

Years earlier, Buckminster Fuller had developed the concept o synergy—thecollective power, more than the sum o the parts, that comes o people and/or phenomena working together in a system—and Homebrew [a Bay Areacomputer club in the 1970s] was a textbook example o the concept at work.One person’s idea would spark another person into embarking on a large project,and perhaps beginning a company to make a product based on the idea. Or, i someone came up with a clever hack to produce a random number generator on theAltair, he would give out the code so everyone could do it, and by the next meeting someone else would have devised a game that utilized the routine.

—“Hackers,” Steven Levy, page 218

. . .built as the result o detailed plans? Christopher Alexander said this:

Let us start by seeing how the great cathedrals, Chartres and Notre Dame,

were made within a pattern language. . . . There were hundreds o people, eachmaking his part within the whole, working, oten or generations. At any givenmoment there was usually one master builder, who directed the overall layout. . .buteach person in the whole had, in his mind, the same overall language. Each personexecuted each detail in the same general way, but with minor di ff erences. Themaster builder did not need to orce the design o the details down the builders’throats, because the builders themselves knew enough o the shared pattern

language to make the details correctly, with their own individual air. . . . Weimagine, because o the distorted view o architecture we have learnt, that some great architect created these buildings, with a ew marks o the pencil, workedout laboriously at the drawing board.

The act is that Chartres, no less than the simple armhouse, was built by a group o men, acting within a common pattern language, deeply steeped in it o course. It was not made by “design” at the drawing board.

—“The Timeless Way o Building,” page 216

. . .but sotware is diff erent, right? Donald Eastlake said this in 1972 about thecreation o the Incompatible Timesharing System at MIT:

The ITS system is not the result o a human wave or crash e ff ort. Thesystem has been incrementally developed almost continuously since its inception.



5

It is indeed true that large systems are never “fnished”. . . . In general, the ITSsystem can be said to have been designer implemented and user designed. The problem o unrealistic sotware design is greatly diminished when the designer isthe implementor. The implementors’ ease in programming and pride in the result

is increased when he, in an essential sense, is the designer. Features are less likelyto turn out to be o low utility i users are their designers and they are less likelyto be di fficult to use i their designers are their users.

—Donald Eastlake, 1972, quoted in “Hackers,” page 127

The Swarm

In “The Lives o a Cell,” Lewis Thomas wrote about termites building arches:

Termites are even more extraordinary in the way they seem to accumulateintelligence as they gather together. Two or three termites in a chamber will beginto pick up pellets and move them rom place to place, but nothing comes o it;nothing is built. As more join in, they seem to reach a critical mass, a quorum,and the thinking begins. They place pellets atop pellets, then throw up columnsand beautiul, curving, symmetrical arches, and the crystalline architecture o

vaulted chambers is created. It is not known how they communicate with eachother, how the chains o termites building one column know when to turn towardthe crew o the adjacent column, or how, when the time comes, they manage the awless joining o the arches. The stimuli that set them o ff at the outset, building collectively instead o shiting things about, may be pheromones released when theyreach committee size. They react as i alarmed. They become agitated, excited,and then they begin working like artists.

— “The Lives o a Cell,” Lewis Thomas, (New York: Viking. 99 1974), p. 13.

One o the remarkable discoveries o recent times is that complex behaviorby a group o individuals requires only that each individual ollow simple rules,and the collective behavior o the group can display acets and fligrees nowhereapparent in those rules. Here are three simple rules:

• Each individual shall steer toward the average position o its neighbors.• Each individual shall adjust its speed to match its neighbors.• Each individual shall endeavor to not bump into anything.

With a group o individuals each ollowing these rules, we observe the simplebut beautiul and graceul ocking patterns o birds and schools o fsh.



6

Simulation is the main tool o complexity investigation. One o the betterknown simulations is “Sugarscape,” which became noted over the past 5 years byrevealing that complex societal behavior could emerge rom a small number o individual behavioral rules alongside simple genetic characteristics.

This is the setup: a simple 2-dimensional grid, a population o individualsinitially spread randomly over the squares. Each square can be occupied by onlyone individual. Some squares contain sugar, which the individual can collect andconsume. In the initial setup, an individual can move and see a certain distance.Movement costs energy regulated by metabolism. An individual scans the horizonor sugar and goes to the square with the most o it while avoiding squares withother individuals. Individuals can hoard sugar. Each cell in the grid has a sugarcapacity, and sugar can “grow back” at some rate ater it is harvested.

I we place two large piles o sugar in the grid, the population splits intwo and eeds as i each pile were covered by a swarm o ants. I we introduceseasons during which the density o sugar moves according to time, we’ll see thepopulation migrate—simply as a result o the simple rules and their interactionthrough individuals with the environment.

O course, because not all individuals are the same—they are created witha distribution o traits such as metabolism rate, visual acuity, and collection

capacity—some are less well than others. Some become at and live orever;others starve, having been born in sugarree badlands.

The next step is to add some simple mechanisms or evolution and socialnetworking: mating and genetic exchange, meme exchange, actor status, affinityor similar agents, repulsion rom diff erent ones, and conorming. Each o these is expressed as simple, local rules. The general principle or complexitydesign is this:

Think locally, act locally.

When inheritance is added—the ability o a parent to pass on its sugarhoard to off spring—visual acuity decreases and the gap between the rich andthe poor widens dramatically.

Cultural transmission and diff usion behaviors emerge. By creating varietieso sugar, economic behavior can be studied. Fads, norms, and ashions emerge.

Isolated areas become closed societies. Adding combat-related rules createswars and power struggles.

Is this eerie? Silly? Important research? Or just so-what?Such phenomena point to an interesting locale in complex systems—the

border between order and chaos. Chaos is unpredictability: Combinations thatmight have lasting value or interest don’t last—the energy or change is too high.



7

Order is total predictability: The only combinations that exist are the ones thatalways have—the energy or stability is too high.

Stuart Kauff man, ormerly o the Santa Fe Institute, wrote:

It is a lovely hypothesis, with considerable supporting data, that genomicsystems lie in the ordered regime near the phase transition to chaos. Weresuch systems too deeply into the rozen ordered regime, they would be toorigid to coordinate the complex sequences o genetic activities necessary ordevelopment. Were they too ar into the gaseous chaotic regime, they wouldnot be orderly enough.

—“At Home in the Universe,” page 26

and

. . .cell networks achieve both stability and fexibility. . .by achieving a kind o poisedstate balanced on the edge o chaos.

—“At Home in the Universe,” page 86

Between order and chaos, interesting and unexpected combinations come

about and last long enough to have repercussions. Trends can be observed.Patterns emerge. The connection to poetry is remarkable: One way to look atpoetry is that release—the wild imagination o Whitman and Garcia Lorca—isreined in by restraint: requirements o orm, grammar, sentence-making, echoes,rhyme, rhythm. Without release there could be nothing worth reading; theerotic pleasure o pure meandering would be unapproached. Without restraintthere cannot be sense enough to make the journey worth taking. Poetry is

at the margins o understanding, in the ractures o our reality, in the spacebetween order and chaos.Listen or a minute to Federico Garcia Lorca at the end o the poem “Scream

to Rome,” written in New York around 1930:

Meanwhile, meanwhile, oh!, meanwhile,

the blacks that take out the spittoons,

the boys that tremble beneath the pale terror o the directors,

the women drowned in mineral oils,the crowd o hammer, violin, or cloud,

will scream although their brains may blow out on the wall,

will scream in ront o the domes,

will scream maddened by re,

will scream maddened by snow,



8

will scream with their heads ull o excrement,

will scream like all the nights together,

will scream with a voice so torn

that the cities tremble like little girls

and the cities o oil and music break,because we want our daily bread,

fower o the alder and threshed tenderness,

because we want to be ullled the will o the Earth

that gives its ruits or all.

This is a poem o duende—neither angel who dazzles but hovers above normuse who whispers and dictates. Duende is a orce that dares us—when we emptyourselves, approach ourselves—to see truly; taunts us into being serious; battlesorder. All that has black sounds has duende. Garcia Lorca says:

The duende. . .is a power, not a work. It is a struggle, not a thought. I have heard an old maestro o the guitar say, “the duende is not in the throat;the duende climbs up through the soles o the eet.” Meaning this: It is not aquestion o ability, but o true, living style, o blood, o the most ancient culture,

o spontaneous creation.—“In Search o Duende,” Garcia Lorca, page 49

Garcia Lorca says the duende

will not approach at all i he does not see the possibility o death—“Poet in New York,” Garcia Lorca, page 162

and

we only know that he burns the blood like a poultice o broken glass, thathe exhausts, that he rejects all the sweet geometry we have learned, that hesmashes style.

—“In Search o Duende,” Garcia Lorca, page 51

Fear o ailure is the ear o death, the ear o duende. Christopher Alexandersaid,



9

All o the Japanese arts recognize that, fnally, you have to meet the ear o death in order to do anything—landscape painting, ower arrangements,and so on.”

—“Christopher Alexander: The Search or a New Paradigm in Architecture,”

Stephen Grabow, page 86

Allen Ginsberg said that to be a poet you must abandon ear o ailure by

. . .abandoning the glory o poetry and just settling down in the muck o yourown mind. . .

—“The Git,” page 145

When you do this—when you do battle with the duende—you might fnda git, a git o talent or insight that will make you think, “Did I say that?” —”DidI do that?” Gits like this are worth cultivating, even in the sotware world. LewisHyde wrote this in “The Git”:

So long as the git is not withheld, the creative spirit will remain a strangerto the economics o scarcity. Salmon, orest birds, poetry, symphonies, or Kula

shells, the git is not used up in use.—“The Git,” page 146

Duende, poetry, and perhaps lie itsel and lie in our works o artifce aredenizens o the boundary between order and chaos. When we look too deeplyinto chaos or inspiration, we fnd only nonsense; when we look too deeply intoorder or completion and closure, we fnd only the boty o boredom and thedisease he carries: ailure and deathlike morphology.

Such an interesting place is the border between order and chaos that DeeHock coined a word or it: chaord. His work rom the mid-1960s has ocusedon how to replace outworn hierarchical, command-and-control organizationsand what to replace them with. Command-and-control systems are based onthe need or control, predictability, and order, things that Stuart Kauff man sayshave no real place in biologically based systems. What is needed is the vigorat the border o chaos and order.

Dee Hock reasoned that i organizations based on biological principleswere to replace traditional command-and-control systems, then the basis orthe sel-organization and emergent behavior o a group o people would haveto be the same as what orms the similar basis in lie: a genetic code. In theSugarscape simulation the genetic code is represented by local rules o behavior.A rule o behavior is like a principle. I a group shares the same principles (Dee



10

Hock fgured) then they would be able to work in emerging concert withoutthe need or command and control.

But nothing can be built without a purpose, some idea o what to build.Dee Hock was trying to construct a system that would accomplish the electronic

exchange o value—that is, money. To build this, he needed to build an electronicinrastructure—a network and accompanying sotware—and an organizationalinrastructure that would carry out the exchange o money the electronictransers promised.

Because Dee Hock took seriously the motto, “think locally, act locally,” heintuited that the best organizational concept or such an undertaking would movedecisions as close as possible to those who eel their eff ects.

The result was known as Visa International, and it still exists today, thoughnot entirely in the same orm.

Dee Hock’s ideas should sound very amiliar. Building a cathedral is theshared purpose, and the builders—rom the master builder down to the mostinsignifcant member o the mob engaged in its construction—knew the elements:Nave, aisles, transepts, the great rose window in the west end, and the chapelsround the east end. The builders shared a set o principles—the common patternlanguage. Alexander said:

But still the power and beauty o the great cathedrals came mainly romthe language which the master builder and his builders shared. The languagewas so coherent that anyone who understood the language well and devoted hiswhole lie to the building o a single building, working at it slowly, piecemeal,shaping all the parts within the common pattern language, would be able tomake a great work o art.

The building grew slowly, magnifcently, rom the impact o the common pattern language rom which it was made, guiding its individual parts, andthe acts which created them, just as the genes inside the ower’s seed guideand then generate the ower.


The Changing Face of Software

Founding assumptions can echo or decades. In sotware we have suff eredespecially rom such echoes. From the earliest days o sotware—rom the

mid-1950s—a particular view has prevailed o what sotware is and why it iscreated that now or soon will make doing our work intolerable.

Computing practice was frst developed as a branch o computability theorybased on a particularly inhospitable set o mathematical constructs: group and



11

semi-group decidability, Thué and other transormational systems, recursiveunction theory, lambda calculus, and Turing machines, to name some. Inmathematical terms, these constructs are equally expressive, universality being the touchstone o expressiveness. With this set o blinders frmly in place, there

is no diff erence between any o these models, and the same logic is applied withequal blindness to programming languages.

Early computing practices evolved under the assumption that the only usesor computers were military, scientifc, and engineering computation—along witha small need or building tools to support such activities. We can characterize thesecomputational loads as numeric, and the resulting computational requirementsas Fortran-like. Early attempts to expand the realm o computing—such as JohnMcCarthy’s valiant attempt with Lisp and artifcial intelligence, Kristen Nygaard’ssimilarly pioneering attempt with Simula, Doug Englebart’s intriguing attemptto expand our usage options, Alan Kay’s later attempt with Smalltalk, and AlainColmerauer’s attempt with Prolog—were rebuked.

The very architecture o almost every computer today is designed to optimizethe perormance o Fortran programs and its operating-system-level sister, C.Further, attempts to consider neuron-based, genetic, or other types o nonstandardcomputational models were soundly rejected, snubbed, and even ridiculed

until the late 1980s.Programming languages have hardly shown one scintilla o diff erence rom

the designs made in the frst ew years o computing. All signifcant programming languages are expressively, conceptually, and aesthetically equivalent to Fortranand assembly language.

In act, what it means to program is hopelessly outdated. Early modelspersist. In 1960, one generally coded up a single program, linked its parts togetherin a monolithic, monochronic puddle o behavior and data—everything broughttogether in one place at one time, everything made consistent by tools thatensure such consistency.

Sotware development methodologies evolved under this regime along witha mythical belie in master planning. Such belies were rooted in an elementary-school-level fction that great masterpieces were planned, or arose as a by-producto physicists shovelling menial and rote coding tasks to their ineriors in thecomputing department. Master planning eeds off the desire or order, a desire

born o our ear o ailure, our ear o death.

How can we tolerate these indignities? The rustratingly simple answer isthe universal nature o programming languages—the act that one can

program in any one o them what can be programmed in any other. We are able



12

to clever our way out o any programming box. The more difficult the task, themore pride we can take in the accomplishment.

We are loathe through either our natures or our upbringing to admit thatthe programming tasks we are called upon to do are too hard with available tools

or that better tools would improve our lives. We cannot easily see that we areboxed into a corner by the assumptions o our ancestors—as correct as thoseassumptions were or seemed to be at the time.

The reality today o programming’s needs are so ar off rom that early view

that we really should be belly-laughing.Until recently, the model o sotware creation and use held that programmers

put together sotware behind closed doors and people used it only ater copieshad been distributed—on oppy disks and CDs, or by downloading. Thisview o sotware distribution is being overturned by the concept o performing software. In this notion, sotware is created whichever way makes sense, but itsonly executing incarnation is on a single or a ew machines connected to theNet, and its users connect to that machine or those machines to use it. On thehorizon is an obvious tipping point beyond which there is just one, immensedistributed system made up o a large number o perorming programs that

interact with each other.Such uture distributed systems will have been built by vastly diverse,

dispersed, and diff erent-minded people—and massive numbers o them. Eachsuch system will never go down, cannot be recompiled rom scratch, and cannever be in total version coherence.

Even in monolithic systems we fnd the same thing. For every major operating system, there are people who absolutely demand and rationally require the newest

backwardly incompatible eatures, and others who absolutely and rationallyrequire the oldest eatures to remain as they are orever.A simple example can be ound in the Java™ language and Jini™ Technology.

Jini is a simple distributed computing model based on the Java programming language. Among other things, it was intended as a model or services—smallbits o unctionality—to discover each other dynamically and create a network o interoperating program parts. These services could be housed withindevices—physically separate computing platorms as ar as Jini is concerned.

Because such a model is new, the defnition o each service is likely to require amaturation period, in which an initially immature service is defned and released,with perhaps numerous improvements subsequently being released. Servicedefnitions are specifed by Java interaces: API’s, in other words.

The natural way or a community o service developers to work is to startwith a provisional service defnition and move through a series o improvements,



13

culminating, perhaps, in a ratifed service defnition residing in the net.jini package. Jini quite cleverly handles this in some cases because the implementation o the service comes along with the device, but the Java interaces may not match verywell. Perhaps they will not obey even the Java binary compatibility rules. There are

no mechanisms within Java to handle mismatched interaces. There are not even anymechanisms to migrate an interace rom one package to another.

This is a problem o interace evolution and simple renaming. I it’s true thatsotware systems must be living systems, our views on the static constructiono programs need to be updated.

Indeed, there are some programming languages that can handle this ormo interace evolution, modeled on similar mechanisms in the database world(so-called schema evolution mechanisms), but these languages are not lookedon avorably.

One o the languages that supports schema evolution or classes operatesby allowing developers to speciy repair code that scampers about when anunrepaired instance is ound and repairs it. Even though the designers o thissystem didn’t think o it this way, this is a clearly biological approach to theproblem: a swarm o small repair agents fxing up code on the y to make it work when the context o its operation has changed.

Every single programming language we have—including Java—is predicatedon the physicists’ model o fgure it out, code it up, compile it, run it, throw itaway. All our computing education is based on this, all our methodologies, all ourlanguages, environments, tools, attitudes, mathematics, prejudices, and principlesare based as solidly and frmly on this rock as Gibraltar is based on the stoneit rests on. Many i not most development headaches come rom precisely thismodel—headaches that programming language theorists ridicule. Every attemptto defne a language to handle this or a computing device to make it simpler is metwith laughter and rejection. And all this in the ace o the act that the reality o programming must be based on precisely the opposite assumptions: Everything changes, every version is necessary, evolution happens.

Resource Limits

T

he history o computing is rie with resource limitations—to the extent that

there was an attempt at a theory in the 1970s to explain intelligence and otherhuman-level perormances using “resource-limited computation.”

We have labored under three types o resource limitations:



14

• Until the 1990s we did not routinely use computers with much more than aew dozen mips and 4–8 megabytes o RAM.

• We typically run development projects undermanned by a actor o 2 or 3 andschedules about 50% too short.

• We typically underspend per unit time by a actor o 2 or 3.

Because o this we’ve managed to build only very small pieces o sotware, andeven those are horribly error-ridden. Because o the apparent need to constantlyinnovate—or obsolete—hardware and to renew ourselves creatively, and becausedevelopment has been done primarily in a landscape riddled by many isolatedislands o similar or identical activities, we have, over the last 40–50 years, writtenthe same code over and over. How many versions o Unix do we need? Do wereally need the ew dozen that we have? How about a text editor more advancedthan Emacs? Are Word, Excel, and Powerpoint really the best possible programsin those categories? We’ve built these programs many times, and we don’t getparticularly better at them.

We have gotten OK at building cathedrals—only we are building the samedozen or so over and over again. Our patterns are too limited and ocused onefficiency, our vision outworn; sources o new language have dried up, and it’s

as i we are caught in a delirium o mere rephrasings.However, the commercial sotware community has developed one particular

response to resource limitation: a evered, workaholic approach to sotwaredevelopment—error prone, hectic, amily-destroying, health-degrading, night-haunting. I you are undermanned by a actor o 2, add a second 8-hour workdayper physical day. I you are operating under a schedule 50% too short, add inanother 32 hours per week by working weekends. Then pray or luck or pushback on eatures and quality.

Scarcity breeds a commodity or exchange economy. Until almost 1980,there were essentially no markets or sotware. Beore 1980, most computerswere owned by companies and used or “large tasks.” When computers werecommoditized, the resource limitations inherent in sotware development becamean opportunity or exploitation, and any relie to those limitations meant lesswealth to go around. Draw your own conclusions.

Order and Modular Parts

Programming language designers made one important breakthrough inbeing able to program eff ectively given insane resource limitations: the

modular part—call it subroutine, procedure, unction, method, or class. Theidea has two parts:



15

• Create a piece o code that perorms some computation.• Create a way to run the code in several contexts.

The frst o these is the code that will be used over and over. Typically, what

this code does depends on the local context. The second o these serves twopurposes: One is to provide a way to inorm the modular part about the localcontext; and the other is to provide a sort o description o the modular part—thisis conveyed primarily by the modular part’s name, but its arguments can sometimesprovide additional descriptions, particularly or methods.

Modular parts seem like the ideal o order: Construction is uniorm,expectations are identical, ear is quashed, calm reigns—because things rarelychange in a fxed landscape. As I implied beore: Why are we continually writing the same sotware over and over?

The Ariane 5 disaster says a lot about sotware development—recall, itwas the European Space Agency rocket that sel-destructed ater its enginenozzles all swiveled into an extreme position, causing the rocket to veer abruptly,rupturing the links between the booster and the core stage, which caused therocket to sel-destruct.

The ailure has been analyzed thoroughly by both the ESA and sotwareproessionals, with most o the discussion ocusing on uncaught exceptions,best-eff ort results, and the oolishness o simply shutting down a system as areasonable approach to ailure. But the ailure was caused by sotware adoptedwithout adaptation rom the Ariane 4. The decision was made to reuse the codeby Ariane 5 sotware developers and designers who had too much confdence incode that had proved successul many times in the past.

I quote rom the report concerning a special eature which continued to runa calibration routine 50 seconds into the ight:

The same requirement does not apply to Ariane 5, which has a di ff erent preparation sequence, and it was maintained or commonality reasons, presumablybased on the view that, unless proven necessary, it was not wise to make changesin sotware which worked well on Ariane 4.—Paris, 19 July 1996 “ARIANE 5: Flight 501 Failure Report by the Inquiry Board,”

The Chairman o the Board: Pro. J. L. LIONS

The ailure, thereore, had something to do with the use o modular parts:ailing to look specifcally at the requirements or the new system and assuming that a similar module or a diff erent system—which was well-tested under realconditions—should be trusted unless proven otherwise.



16

I we look at ourselves literally as systems we notice soon enough that althoughwe are each made o very similar parts, we are not made o modular parts. Armslook like modular parts, but they aren’t. Each is custom grown or the person whohosts it. Within each person’s genetic code is the knowledge o how to grow an arm

in place, custom ft to the body being created concurrently.Moreover, we already seem to know this in some aspects o mainstream

programming. A database may seem like a modular part, but it isn’t. A databaseis created by taking off -the-shel genetic coding in the orm o a database system.Then we reckon up schemata defning how the data will be laid out, and weadd data to made a database.

Let’s listen to Christopher Alexander on the topic o modular parts:

The details o a building cannot be made alive when they are made rommodular parts. . . . And or the same reason, the details o a building cannot bemade alive when they are drawn at a drawing board.

—“The Timeless Way o Building,” pp. 460–461

Modular parts: Maybe they aren’t so wonderul.

The real problem with modular parts is that we took a good idea—modularity—

and mixed it up with reuse. Modularity is about separation: When we worryabout a small set o related things, we locate them in the same place. This ishow thousands o programmers can work on the same source code and makeprogress. We get in trouble when we try to use that small set o related thingsin lots o places without preparing or repairing them.

Who Can Be Programmers?

Computing practice and theory is based on the very hidden and hard-to-revealassumption that engineers, mathematicians, and computer scientists are the

only ones who will write a program or contribute to a sotware system. Whenthe computing age began, no one but scientists and the military even remotelyconceived o the utility o programs and programming. Today, almost everybusiness and human pursuit is built on computing and digital technology. Artists,

cratspeople, writers, fshermen, armers, tightrope walkers, bankers, children,carpenters, singers, dentists, and animals depend on computing, and most o the people I mentioned want to have a say in how such sotware works, looks,and behaves. Many o them would program i it were possible. The currentsituation might eel fne to some o you, but suppose all computing were based



17

on the needs o tightrope walkers? Hard to imagine? What we’ve created washard or them to imagine.

Literature of Code and Teaching

Fast-lane capitalism has created a nightmare scenario in which it is literallyimpossible to teach and develop extraordinary sotware designers, architects,

and builders. The eff ect o ownership imperatives has caused there to be no bodyo sotware as literature. It is as i all writers had their own private companies andonly people in the Melville company could read “Moby-Dick” and only those inHemingway’s could read “The Sun Also Rises.” Can you imagine developing arich literature under these circumstances? Under such conditions, there could beneither a curriculum in literature nor a way o teaching writing. And we expectpeople to learn to program in this exact context?

When sotware became merchandise, the opportunity vanished o teaching sotware development as a crat and as artistry. The literature became rozen. It’sextremely rare today to stumble across someone who is amiliar with the samesource code as you are. I all remnants o literature disappeared, you’d expect thateventually all respect or it—as an art orm, as a crat, as an activity worthy o

human attention—would disappear. And so we’ve seen with sotware: The ocus ison architecture, specifcations, design documents, and graphical design languages.Code as code is looked down on: The lowest rank in the sotware developmentchain is “coder”—right alongside QA drone and doc writer.

We fnd little or no code education. Typically a student will write a ew dozensmall programs over the course o an undergraduate education, and perhaps he orshe will work on a larger program—such as a compiler—with a small group o students. At that point, the student is ready to become a proessional programmer.Little or no mentoring is done ater that, and i the student becomes a profcientprogrammer, it is due to luck and hard work, in that order.

Birth of Mob Software

Aew years ago, the open source community posed a signifcant question—aquestion which has been drowned out in debates over licensing and the

politics o open source. The question was:

What i what once was scarce is now abundant?

Hidden in the premises o open source is the belie that perhaps it’s acceptableto waste programmer time. Moreover, there are no time limits to open-source



18

projects. With lots o people looking at the source code, it’s easy to see howthe quality o the resulting code could be a little higher. And with hackersalways desperate to prove themselves wizards, it’s easy to see how “customersupport” could be a little better.

Because the open source proposition asked the crucial frst question, I includeit in what I am calling “mob sotware,” but mob sotware goes way beyond whatopen source is up to today. What I’m talking about is the kind o swarming activity we see exhibited by social insects, a kind o semi-chaotic sel-organizing behavior in which numerous small acts o repair with a common goal in mindcan lead to quickly built, complex, and massive creations. Mob sotware isdivergent—it explores the space o possibilities. It includes users during design.It is highly incremental, ocusing on repair rather than master planning. Mobsotware takes coding out o the closet and makes code literature. It is basedon gits. Mob artiacts include massive sotware, built by the multitudes. Itnever goes down, it is never totally stable but is stable in the aggregate. It isexible in the extreme. Anyone can add to it. Mob-sotware artiacts adapt,evolve almost. It is living while all the sotware we have now—almost all o it—is dead-dead-dead. Mob sotware is the technical sotware community fnallycoming to grips with the duende.

Open source is only some o these things, but it provides our frst view intomob sotware, so let’s talk about open source or a moment.

By now we know about quite a ew mostly successul open-source—orbaby mob sotware—projects: Linux—which has won a number o awardsor customer support and artistry—Mozilla, Jikes, Emacs, GCC, Apache, Perl,Python, sendmail, and BSD.

The Early History of Open Source

Sadly? Happily? Oddly?—well, open source and the mob approach is justnot a new idea. A great deal o sotware development beore the 1980s took

place in conditions similar to those propounded by the open source olks. I your organization owned a computer, you had a copy o the source code ormany o its systems. Back in the 1960s and ’70s, PhD dissertations in computerscience—and especially in artifcial intelligence—contained the source code or

the program described in the dissertation. In 1962, the Lisp 1.5 Programmer’sManual contained the mysterious, almost gnostic, Lisp code that implementedLisp. Though mostly obvious to mathematicians, this Lisp in Lisp took severaldecades or computer practitioners to get their heads around.

Throughout the 1960s and ’70s, and even into the 1980s, it was relativelycommon to exchange source code. The nascent Internet—called at the time,



19

the Arpanet—was created in order to make computing acilities available toresearchers around the world, and to exchange fles including source code. One o the frst net-based “open source” projects was Maclisp—a PDP-10–based simpleLisp that became one o the dominant Lisp dialects in the 1970s. Originally

developed at MIT under ITS, it was ported to several other popular PDP-10operating systems by a group o about 10 volunteers who donated their time andworked on the code partly at their own locations and partly over the Arpanet.Developers who earned the respect o the principal maintainers o Maclisp atMIT were given the authority to edit the sources on MIT’s computers andto build Maclisp there.

Similar activities took place: Languages, environments, planning systems,natural-language understanding systems, game-playing programs, games, texteditors, compilers, graphics programs, window systems, typesetting systems—justabout anything you can think o was written this way, though on a smaller scalebecause there were hundreds o computers on the Arpanet, not the nearly 100million we have on the Internet today.

In the 1980s, it became apparent there was money to be made by writing and selling sotware, and that a premium might be had or being clever about it.Although sotware patents were frst tried about 10 years earlier, they became

increasingly popular during the 1980s until the 1990s, when the intellectualproperty grab came to resemble the Oklahoma land rush.

At that point, except or academic projects and the activities o the FreeSotware Foundation under the eclectic oversight o Richard Stallman, sotwaresource code essentially disappeared.

The Dictionary

Mob development—the creation o sotware by a loosely coupled group o volunteers—seems a thoroughly contemporary phenomenon, based on the

ree outlook o the 1960s, a kind o allout o ree love and hippiedom—I mean, just look at the proponents o this approach: anti-establishment Marxists whobelieve in ree sotware, who call themselves “hackers”; people with scruff y hair,who don’t exactly work or a living, people who attend Star Trek conventions andthink science fction is both high literature and true science.

However, the idea is a bit older. On Guy Fawkes Day, 1857, Richard ChenevixTrench, addressing the Philological Society, proposed to produce a new, completeEnglish dictionary based on fnding the earliest occurrences o each o the Englishwords ever in printed use. That is, the dictionary would be constructed by reading every book ever written and noting down exactly where in each book a signifcantuse o every word occurred; these citations would be used to write defnitions and



20

short histories o the words’ uses. In order to do this, Trench proposed enlisting the volunteer assistance o individuals throughout English-speaking countriesby advertising or their assistance.

Over a period o 70 years, many hundreds o people sent in over 6 million

slips with words and their interesting occurrences in thousands o books.This resulted in the Oxord English Dictionary, the ultimate authority onEnglish, with 300,000 words, about 2.5 million citations, 8.3 citations perentry, and in 20 volumes.

Compare this with the best eff ort by an individual—Samuel Johnson—who,over a 9-year period, using the same methodology and a handul o assistantscalled amanuenses, produced a 2-volume dictionary with about 40, 000 wordsand in most cases 1 citation per entry. As we look at these two works, Johnson’sdictionary is a monument to individual eff ort and a work o art, revealing asmuch about Johnson as about the language he perceived around him, while theOED is the standard benchmark or dictionaries, the fnal arbiter o meaning and etymology.

Why Mob Software Works

Mob sotware works by involving a multitude o developers who are passionateabout the sotware being constructed because it is important or them.

Mob sotware projects do not generally have deadlines, but efficiency is gainedby more eyes, hands, and minds being applied to the work—in general, ewermajor releases are required to get to the same level o unctionality and quality.To get an idea, whereas a large sotware project by conventional standards mighthave 250–500 developers, a mob sotware project can have thousands or tens o thousands o developers who are not only actively working on the sotware butusing it every day under a variety o conditions. Moreover, these developers span arange o talents almost no employer could aff ord to hire. Further, these developerstypically include some individuals who have remarkable abilities along withastounding disabilities—they might not even be employable.

Among the main volunteers to the OED project was Dr. William C. Minor, abrilliant etymological worker who, during his entire 30 or so year involvement withthe OED, happened to be locked up in an asylum or the criminally insane, where

he suff ered hallucinations that kept him awake all night most nights and where heeventually mutilated himsel in the most horrifc manner. Once incarcerated, hewas never entirely outside immediate and confning care. Yet he was acknowledgedas one o the most important contributors to the project.



21

Monolithic Development

Some might think that my claim that we don’t know how to do massivesotware is exaggerated, that we do know and it’s called SEI Level 5, the highest

maturity rating. And the story that explains how things should work is not the oneabout the OED but the one about space shuttle sotware.

Lockheed Martin Corporation employs a Level 5 sotware group that putstogether the shuttle sotware. This sotware seems large, and it is written by adeliberate process. Let’s look at this.

The sotware is not very big—only 420,000 lines o code. This is not massivesotware—it’s off by a actor o 10 or 100. The sotware is monolithic, an unrealisticmodel or uture systems. The sotware was developed over a 20-year periodby a group o 260 people. These numbers imply that each line o code has had25 person-hours o attention, and that each person has been responsible or alittle over 1600 lines o code—25 pages. $700,000,000 was spent to developthis code, or about $1700 per line.

Further, the sotware had been completely specifed in pseudo-code agreed tobeorehand. The task o a programmer in this regime is to translate pseudocodeto actual code. But, all this work does buy NASA only 1 error in each o the

last three releases o the code. Because we cannot aff ord to have deaths in thespace program, the cost and eff ort are worth it. The cost amounts to making eachsubroutine a career-long research project. Twenty years, 8 hours a day, studying and eliminating errors rom 1600 lines o code.

The mob-sotware theory is that this project needed 26,000 programmers,not 260. The job could have taken less than a year, probably with better quality,and a lot cheaper. Better quality because the range o talent that could have beenbrought to bear would have been tremendously greater, and cheaper becausemost o the work would have been a git. (Motivating volunteers who cannot beusers takes a culture o git-giving we don’t have yet.)

We cannot aff ord to inch our way up the learning curve, 1600 lines at a time.We need to get things done ast while doing some learning along the way.

Gift and Commodity Economies

To understand what the open source and mob sotware movements are trying

to do, it helps to make a distinction between a commodity economy, to whichwe are accustomed in a capitalist society, and a gift economy. In a git economy, gitsare exchanged, orming a bond based on mutual obligation: In the simplest ormo git exchange, when one person gives a git to another, the receiver becomesobligated to the giver, but not in a purely mercenary way—rather, the recipient



22

becomes very much like a member o the giver’s amily where mutual obligationsare many, varied, and long lasting. More sophisticated orms involve more thantwo parties—in act the cosmos may become involved. A person may give a gitwith the realistic expectation that someday a git o equal or greater use value

will be received, or that the recipient will pass on a urther git. Sacrifces andmany religious ceremonies are git-economy based. In an open-source project,the git o source code is reciprocated by suggestions, bug reports, debugging,hard work, praise, and more source code.

Git economies are embedded within non-economic institutions like kinship,marriage, hospitality, artistic patronage, and ritual riendship. The bond is solike esh and blood that the Greek git economy persisted alongside a vigorouslygrowing commodity economy or several centuries.

A git has both economic and spiritual content. It is personal. In giving a gitthe goal is to become as empty as possible. In “Git and Commodity in ArchaicGreece,” Ian Morris wrote the ollowing:

The aim o the git economy is accumulation or de-accumulation; the git economy is above all a debt economy, where the actors strive to maximizeoutgoings. The system can be described as one o “alternating disequilibrium”

where the aim is to never have debts “paid o ff ” but to preserve a situation o personal indebtedness.

—“Git and Commodity in Archaic Greece,” Ian Morris

In a typical git exchange situation, a patron would provide ood and shelterto a poet in exchange or poems about the patron. I you look at this exchangeclosely in the terms in which it was made, you can see it as a trade o lie sustenanceor memory ater death. Moreover, each would enjoy the company o the other atthe dinner table, and in many cases the wit and eloquence o the poet would be aurther git to the patron and by the patron to his guests.

Notice that in this hypothetical exchange, the gits are tangible and their valueresides in how they can be used: Food is used or sustenance and a poem is used tomemorialize the patron in speech beore death and in script ater. The gits are thusinalienable—their value cannot be separated rom their identity.

In a commodity economy, the value o an item is abstracted into some

other sort o object whose intrinsic value is unrelated to its “purchasing power.”For gold coins this characterization makes less sense than it does or papermoney, which is the ultimate abstraction: Paper money is completely real andyet unrelated to what it abstracts—so much so that it is possible through themedium o paper money to make a completely air trade between otherwise



23

incommensurate things, such as 500 cotton candy cones or one handgun throughthe alienable intermediary o $500.

In a commodity economy, money is an alienable object exchanged byindependent transactors. In such an economy there is no need or the poet to

sit at the patron’s dinner table, and in act, the poet may have many anonymousand alien patrons who fnd the work ulflling or not. More than that, thepoems the patron receives provide nothing personal to the patron at all, andthe term “patron” inherently makes no sense whatsoever in this case—alienpatrons are merely donors.

Most importantly, the commodity economy—let’s call it capitalism—dependson scarcity. Its most amous law is that o “diminishing returns,” whose working requires a fxed supply. Scarcity o material or scarcity o competitors makeshigh proft margins. It works through competition.

The git economy is an economy o abundance—the gits exchanged areinexhaustible, consisting o ritualized riendship and hospitality.

The git and commodity economies have co-existed or millennia, generallywith the most intimate relationships governed by git, not money. Tribesbased purely on git economies will barter and exchange money or goodswith outsiders. A healthy Western amily operates on a git economy. For mob

sotware to succeed in communities that include corporations, the source-codegit-based economy needs to thrive alongside the commodity economy hovering on its boundaries.

The ollowing quote illustrates the difficulty o co-existence as observed in6th century BC Greece. In it, the Greek word xenia means “a bond o solidaritymaniesting itsel in an exchange o goods and services between individualsoriginating rom separate social units.” (Gabriel Herman, quoted in “Economyo the Unlost,” page 13):

For whereas money is concerned to change the status quo, gits aim to sustainit. The proound conservatism o a git economy secures its own continuance andmoral prestige in two ways: First, by derogation o all that is not git. We cansee a deep distrust o money, trade, proft, commerce, and commercial persons pervading Greek socioeconomic attitudes rom Homer’s time through Aristotle’s.“Commodity exchange was not an acceptable activity or a Greek.” [“Git and

Commodity in Archaic Greece,” Ian Morris]. . .At the same time, a giteconomy likes to project its unctions onto the cosmos. . .as i the rules o xeniarepresent the way things are or gods and men.

—“Economy o the Unlost,” Anne Carson



24

In the git economy, the most empty individual is the wealthiest, being the most likely to receive gits, while in the commodity economy, the richestindividual is the wealthiest, being the most likely to receive urther riches.Trying to reconcile these two economies today will be tough because the git

economy must encroach on the commodity economy, not the other way aroundas it has always been.

Listen to Lewis Hyde:

. . .the exploitation o the arts which we fnd in the twentieth century is without precedent. The particular manner in which radio, television, the movies, andthe recording industry have commercialized song and drama is wholly new. . . .The more we allow such commodity art to defne and control our gits, the less gited we will become, as individuals and as a society. The true commerce o artis a git exchange, and where that commerce can proceed on its own terms weshall be heirs to the ruits o git exchange:. . .to a creative spirit whose ertility isnot exhausted in use, to the sense o plenitude which is that mark o all eroticexchange, to a storehouse o works that can serve as agents o transormation,and to a sense o an inhabitable world—an awareness. . .o our solidarity withwhatever we take to be the source o our gits, be it the community. . . , nature, or

the gods. But none o these ruits will come to us where we have converted ourarts to pure commercial enterprises.

—“The Git,” pp 158–159

Xenia involves emptying one’s sel, and along with this emptiness comesthe duende and with it risk-taking, creation, diversity. The Chilean poet, PabloNeruda, connected xenia and the duende in this story rom his childhood inthe southern rontier o Chile:

I looked through the hole [in the ence] and saw a landscape like thatbehind our house, uncared or and wild. I moved back a ew steps because I sensedvaguely that something was about to happen. All o a sudden a hand appeared—atiny hand o a boy about my own age. By the time I came close again, the handwas gone, and in its place there was a marvellous white toy sheep. . . . I went intothe house and brought out a treasure o my own: a pine cone, opened, ull o odor

and resin, which I adored. I set it down in the same spot and went o ff with thesheep. . . . Maybe this small and mysterious exchange o gits remained inside mealso, deep and indestructible, giving my poetry light.

—“The Git,” pages 281–282



25

Hooray for Literary Theory

The postmodern lie is one o stories and personae. Literary theory—the

study o how literature and art, in some cases, works—orms one set o

techniques or understanding the parts o our lives in common with technology.One avorite concept is topos.

“Topos” is a term used in poetics and can be defned this way:

a conventionalized expression or passage in text which comes to be used as aresource or the composition o additional texts

—The New Princeton Encyclopedia o Poetry and Poetics

“Topos” literally means a place or location in Greek, and a topos is a place romwhich similar stories can be woven. An example rom literature is the Garden o Eden. Anyone in a Western Judeo-Christian culture asked to tell a story aboutthe Garden o Eden would likely come up with a story that was consistent withthe “vision” o creation the Garden o Eden presents.

Topoi we’re already amiliar with include the shared purposes needed tobuild a cathedral or one o Dee Hock’s chaords.

The Mob Eff ect Can Take Over, and Unexpected Plenitudes Ripen

The open-source community asked one question and answered it in a provocativeway. They asked: “What i what once was scarce is now abundant?”With their licenses they have ound a gate through which some o us

have passed. Christopher Alexander said one very important thing that isrelevant to us today:

And yet the timeless way is not complete, and will not ully generate the qualitywithout a name, until we leave the gate behind.


It is only when we orget the ideas behind building something wonderulthat we can actually do the building that makes things wonderul. Time and

again I’ve heard poets and musicians talk about the letting go required to maketrue art or music. The battle to let go is the battle with the duende. It leads us tothe place where order meets chaos, where the phase transition between stabilityand exibility makes things happen.

Unortunately, the open-source community is extremely conservative,ocusing solely on the need to build up slowly a parallel open inrastructure



26

next to the proprietary ones already in place. They are working on an operating system; development tools like compilers, development environments, versioncontrol systems, and bug tracking systems; web servers; e-mail and othercommunications tools; a desktop; productivity tools; web browsers; and a

small host o suchlike.The image I have is o hackers encamped just outside a stone gate, careully

but joyully building, well, cathedrals, just like those within the town. From along distance, they appear huddled by the gate as i rightened by what may liebeyond in the unknown. It is a slightly bitter image.

Their philosophy is to build up a single reliable layer. Although the classicopen-source licenses permit orking, it rarely happens because a ork is aailure—there is a right place to go and a right thing to build. The design centeris whatever the hacker community likes, because the motivation is to createa world o open source that companies can never take away rom them. It’sa matter o liberation, and that’s why it can be hard or companies to launchsuccessul open-source projects.

One diff erence between open source and mob sotware is that open sourcetopoi are technological while mob sotware topoi are people centered. The

Jini topos speaks o a world o “simply connect” and “spontaneous networks”

accompanied by a set o home, office, and automobile scenarios derived rom thistopos. The concepts o “simply connect” and “spontaneous networks” address howpeople relate to the technology. The Jini topos was highly eff ective and created athriving community and associated technology—as hoped—along with thriving E-Speak, UPnP, and SOAP communities and associated technologies. Jini wasone o the frst explicitly mob-sotware projects.

The Apache topos speaks o web servers and technology or making them eff ective. Consequently, while Jini projects tend to an out creating newservices or people to use, Apache projects tend to ocus on adding web serverunctionality and adopting related technologies such as Java Server Pages,servlets, and XML.

Open-source projects tend to be convergent: Each project is aimed at aparticular artiact in the end. Mob-sotware projects tend to be divergent: Thegoal is to build variety and diversity so that competitive orces and naturalselection in the user realm can take over.

Both open-source and proprietary sotware projects are internally highlyordered: In both cases there are only a ew developers in core teams; in opensource, there is a halo o occasional or opportunistic developers who chip in work,fx bugs, and make small changes. Proprietary projects are tightly managed bycommand-and-control systems; open-source projects have small core teams ledby module owners who are strict gatekeepers. Both open-source and proprietary



27

commercial sotware projects populate the world in an orderly ashion. Proprietarysotware projects rationally pick and choose what products to make based onbusiness goals, and hope scarcity doesn’t kill them beore they fnish. Open-sourceprojects pick and choose what to build based on technological needs and desires,

and ear scarcity o interested people.Rarely in either regime is the ash o duende ollowed by natural selection

as strong as we’d hope or—as strong as in a living system. Mob sotware is aboutthe boundary between order and chaos where lie emerges and thrives. What isit like, the landscape o mob sotware?

Picture this: All devices that include computing elements are connected, andtheir collective sotware orms one large system. Pieces and chunks o this systemsometimes go down or disconnect—later they might rejoin. The collective sotwareworks together even though its parts exist in multiple versions o diff erent ages.Taken in the large, the sotware is continuously being upgraded and downgraded.Some parts o the sotware are perormance only; other parts are private copies.Almost all the source code or this massive system—estimated in the billions o lines o code—is available under a license that grants total recombination rights:Any ragment o source code can be used or any purpose.

Companies dip into this pool to collect pieces and parts to build customsotware or their own use. Doing this reduces their development costs to araction o what they once were. Following the precepts o xenia, these companies,or the most part, return their custom code to the pool. Other companies dip intothis pool to create niche sotware; they augment their businesses by supporting this sotware and helping their clients.

The oibles o modular parts are minimized because each potential part isscrutinized and accumulates usages and annotations about its applicability andlimitations. The part becomes productized, more like a library than a one o akind; its size and scope is adjusted—in short, it evolves rom many uses and publicscrutiny. Unlike a stray bit o code which needs to be inspected and understoodbeore it is reused, its constant and varied use provides confdence.

Customization is easy. Ordinary people trade and share customizations as easilyas they trade and share recipes and thank-you-note templates. Customizations arelargely data and schemata which are used to generate customized programs—just

as databases today are so generated. Many companies do customizations orvarious segments o the population who pay modest amounts or it. Specialinterest groups perorm customizations or their members—specialized versionso sotware are created or the disabled, the exceptional, diff erent vocations, andor diff erent work and play situations.



28

These customizations are not merely cosmetic, but go deep into the sotware.The variation in user interaces or the same application is wider than thediff erence between punched cards and virtual reality. The end-user has beenbrought into the design process, creating a whole new range and variety o

business opportunities. No more are interaces designed or the hypothetical“average” person. Each person can have his or her own interace without imposing on an overworked development team.

Programming is mostly a process o adaptation partially automated by swarmso small bots that perorm tasks such as interace evolution.

All sotware development takes place on the common corpus o source codeby a mob o volunteers and developers paid by companies who reap benefts romthe source base. Developers work primarily on projects o particular interestto them. Allowing people to choose their domains o expertise encouragesartistry and cratsmanship. Mentoring circles and other orms o workshopare the mainstay o sotware development education. There are hundreds o millions o programmers.

The literature o code and its study spawns a passion or beauty and diversityin sotware which combined with a deep interest in user experience sponsors acreativity heretoore rarely observed in sotware development. Risk-taking and a

willingness to open one’s eyes to new possibilities and a rejection o worse-is-bettermake an environment where excellence is possible. Xenia invites the duende,which is battled daily because there is the possibility o ailure in an aestheticrather than merely a technical sense.

These developments arise rom the organization o the community builtaround source code. This community has no fxed organization, nor is there astandard or typical way to work within it. Projects spring up, ork, spawn otherprojects, mutate, continue on, shut down; experimentation is encouraged; rarelyare standards set, but when they are, the process is adapted to the situation whilerespecting the basic rights o community members. Like Dee Hock’s chaords orthe Jini Community, new parts o the organization are designed by its participantsas needed, the design being inormed by principles and pattern languages. Rights,principles, and ethics—or both individuals and corporations—are encoded inthese community principles and pattern languages.

The community has a culture similar to the current open-source culture, but

it is much more accepting o users, especially novice users—it’s as i the spirito xenia has raised to the highest status everyone with a stake in the community.Users participate in design at all levels o scale, and projects are begun specifcallyto address the needs or wants o a particular user community.

Moreover, experimentation and risk-taking emerge rom the individual smallacts o the community acting as a group mind. Because a basic inrastructure has



29

already been laid down, the reedom to pursue new ideas has become possible.Resource scarceness created by artifcial boundaries no longer exists, and in anera o abundance, excess thrives.

Users and others create a new project by creating a topos or it—this is very

hard work. By expressing a shared purpose, the topos, when honed and turned,becomes the attractor or developers to join in building its vision, in making it real.The topos as a story-making story attracts and provides room or experimentationand variation beyond what the initiators envisioned.

Forces That Get Us There

This sounds antastic—I mean, it sounds like a antasy. But a antasy like this

happened within the last 10 years, and another is under way.The World Wide Web was frst envisioned as a way to publish and cross-

reerence scientifc papers. It was based on some o the least attractive technology everto come down the road. I, somehow, it were possible to limit our view to web pagescreated by technologists and technology lovers—computer company sites, open-source sites, online computer ’zines—we would observe mediocrity, homogeneity,and bland. Let’s ace acts: As artists, we’re good programmers.

But the technology was accessible to real people, and the Web grew almostboundlessly. Many sites are unbelievable: sites by artists, writers, galleries, glassblowers, urban diarists, monasteries, punks, the Vatican, architects, people withweird pets, pornographers, gnostics, stores, and children. We have cameras:Iguana Cam, Madagascar Hissing Cockroach Cam, Naked Molerat Cam, CornCam, and a range o cams best let imagined.

The lesson is simple: When opened up to real people, technology can blossom.The world envisioned by technologists is limited and at, like the world o dog breedswhen compared to the real diversity o species the world aff ords.

Under way is open source, demonstrating it is possible to do high-quality andeff ective, yet wildly distributed development with small snips o sel-organizationand reely available source code.

As companies join open-source projects over the next ew years, communitiesincreasingly will be built that include end-users o all stripes, and as desktopopen-source systems are built, there will be increasing pressure brought to bear

by the end-users or better usability, realistic customizability, and participationrights.

Perorming sotware will put pressure on sotware development philosophy,and practitioners o perorming sotware will more quickly see that we needto consider version maintenance and schema evolution applied to sotwaremodules.



30

As the code literature grows, we can start a literary discipline based on itand begin teaching code artistry once again—a literature o source code, userinteraces, and execution perormance. When we do this we’ll fnd that thedurability, utility, and beauty o our sotware begins to take off until it isn’t

silly to consider it a literature.Economic sea changes don’t come that oten—and we’re in the middle o

one right now. Art, publishing, and music businesses are all changing, as are ourideas on copyright and intellectual property. The economic exploitation o artistsand writers is relatively new, and perhaps it won’t survive the drit back to the giteconomy we’re witnessing. The names are silly, but or every Metallica againstonline sharing there’s a Limp Bizkit in avor. Stephen King is directly publishing on the Web. Many o my poet and fction writer riends are sel-publishing or at least sel-promoting and sel-distributing using Amazon and all the rest.This change is happening in the sotware world too, with some major computercompanies heavily into open source.

As in 6th century BC Greece, we may end up with a hybrid o the git andcommodity economies—fnd ways to adapt.

I’ve spoken o gits, swarms, mobs, repair, biology, ailures, and the duende.

Mention o master planning, sotware process maturity levels, modular parts,mathematical reasoning, and all the other trappings o mainstream sotwaredevelopment were either snide, sarcastic, demeaning, or insulting. Sotwareskill is a git rom an unknown and unknowable source—perhaps the skill isan artistic talent, perhaps there are parts o the process o writing sotwarethat can be taught.

We can never move orward—we can never move orward—while the bulk o sotware work is done in secret and while wholly inadequate resources are givento it. Currently, almost all sotware development work is carried out in a waythat cannot result in beautiul, living, adaptable artiacts. Unlike our riends inthe built world, we just started to populate the landscape with beautiul sotwareneighborhoods when the air hand o the commodity economy moved in likeWilliam Levitt’s bulldozers and assembly-line house stampers.

The frst Levittown—once called Island Trees—was a postwar innovationin low cost housing in which a potato patch on Long Island was turned into the

frst mass-produced housing tract. Ater the oundation was laid, specializedcrews would descend on each lot one ater another so ast that 18 houses werecompleted in the 8 to noon shit—one could say they used an especially brutaland efficient pattern language. Many lamented the approach. Peter Bacon Haleswrote o the criticism:



31

The accusations against Levittown rom the frst ocused on its relentlesshomogeneity, the cramped quarters o its interiors, and the raw, unfnishedquality o its landscape.

—http://www.uic.edu/~pbhales/Levittown/, Peter Bacon Hales

Architects, artists, and even some computer scientists have used Levittownas an example o how modernism—belie in reductionism and the ultimate valueo the machine—can lead to the deathlike morphology o late 20th and early21st century lie, the unimaginably dulling eff ect o sameness and inhumanityon ordinary lives. I might have argued that, being made o nothing but modularparts laid out on curved roads, Levittown metaphorically epitomized what Ifnd rightening and discouraging about contemporary sotware design andconstruction.

Postwar Americans needed aff ordable housing near jobs to raise the frst waveo baby-boomers, not unaff ordable aesthetics. The houses were snapped up whiletrucks hauling tools and pulling trailers carrying bulldozers drove away towardtheir next project. The architects, designers, builders, and developers did notcare to learn rom their projects, and the United States experienced an unending

string o housing projects ever since that imposed a planned living experienceon people bent more on living than on planning.

Levittown relied on wood raming, but many other projects cast their designsliterally in concrete. The Pruitt-Igoe apartments in St. Louis won architecturalawards in the mid-1950s or low-cost housing design. But the two complexeswere simply steel and concrete highrise warrens in the mold o the Swiss architectLe Corbusier who said

a house is a machine to live in—“Cities o Tomorrow,” Peter Hall, page 205

and

the design o cities is too important to be let to the citizens —“Cities o Tomorrow,” Peter Hall, page 207

Seventeen years ater being completed, the Pruitt-Igoe complex wasdynamited, creating a vacant lot still mostly vacant, signaling the beginning o the postmodern era.



So in 1951, the designers o Levittown—designers just like us—watched asamilies poured in to begin lie in the careully planned and constructed warrensrelentlessly devised according to modernist principles o machine love.

The world, however, did not wait, but soon observed what ollowed on.

Nature, the Levittown community, and the duende did not care about themaster plan: The bulldozed landscape began to sprout trees and shrubs, andover a period o years as economic realities changed, the community developeda sense o innovation, and its inhabitants a control o their own destinies. Notbeing trained as architects or builders did not aze them. They thought locallyand acted locally. The community, through small acts o repair, transormed ahomogenized and orderly Levittown into a place deserving the name Island Trees.Customization, additions, remodels, landscaping, disorder—the community,acting as a multitude or aggregation o persons regarded as not individuallyimportant—as a mob—made Levittown over.

Let me fnish by again quoting Peter Bacon Hales, art historian rom theUniversity o Illinois at Chicago, who wrote the ollowing or the mob-inestedWorld Wide Web:

The raw, new quality o the landscape, too, didn’t seem so awul to new

renters and (a little later) owners, who knew that the trees and grass would quickly grow, and who understood the Levitt salesman’s pitch promising opportunities to personalize the interior and exterior o your Levittown house. Lie [magazine]ran a contest, seeking the best-decorated Levittown house, and the winner was arather startling red-themed Mandarin-Revival Sino-Asian extravaganza. Overtime, Levittown houses changed character, as their occupants rose in status andin economic wealth, and as amilies expanded and community standards o

innovation and growth trickled rom the home-improvement seminars at theCommunity Center and later the High School, out into the Saturday projects andsummer vacation plans o Levittown residents. Today’s heterogeneous Levittownis a testimony to the resilience o the community. . . .

—http://www.uic.edu/~pbhales/Levittown/, Peter Bacon Hales

Where I’m rom, the birds sing a pretty song and there’s always musicin the air.

Mob Software

Documents

Transcript of Mob Software