Google+ is oddly Facebook-like. This makes sense, given that FB is well-used by people of all ages in many countries. The design and interface are battle-tested (if also trivially and endlessly changable). But there’s a key difference, and one that started me thinking about the real business that Facebook is in.

That difference is, of course, the prominence of “Circles” in Google+, and the near-absence of features in Facebook for segmenting and targeting your communications. Sure, one can create friend groups in Facebook, and then make status updates for just a friend group, but I’ll bet a lot of you either didn’t know that, or had never used it. Heck, I’ve never used it despite my expressed desire on Facebook for just such a feature. It’s nearly invisible on Facebook.

It’s central and prominent on Google+. Google wants us to *limit* and control, for ourselves, to whom we target our words and images. Twitter almost insists upon the opposite, that we speak boldly into the ether, and whomever is listening will hear, whether we know the person or not.

I’d bet that at Facebook, any feature which restricts the *volume* or *velocity* of messages that flow within the Facebook global social network are verboten, or anathema. But at the same time, Facebook positions itself as providing control and “privacy,” despite numerous well-publicized privacy issues.

Twitter largely self-organizes as a social network. Facebook, on the other hand, is *crafting* the global social network. It encourages us to accept the illusion of privacy in order to get us to friend more people, post more status, and expose our opinions and information than we would be willing to otherwise. We should not, as a result, study the Facebook social network as if it were a reflection of our real-life social networks, because the two networks are different both in topology and in weighting.

What Google+ is trying to do, and how that intent will translate into reality once it’s fully up and running, I have no idea. It is, perhaps, not entirely clear to Google themselves, since they seem to start with goals and ideas, and let data and experiment drive them toward an ultimate plan and implementation. In fact, I’ll bet the social network scientists and researchers at Google have studied the Facebook social network and its dynamics better than anybody else except Facebook’s social network scientists, and know a good deal about what makes it tick and what makes it sick.

But it’s safe to say that they’ve made a couple of bets. One is that Google is willing to accept a slightly lower velocity and average quantity of messages in the system. This is inevitable because people will restrict more highly to whom they send various status and messages if the means for doing so is prominent and core to the system’s operation. The degree to which this effect will be prominent is open to question, but the underlying inequality in rates is pretty much built in. They would make this bet if the increased loyalty they get from customers yields a better upside.

Second, they’re betting that running a more organic and self-structured social network will yield better growth than a manipulated and engineered social network. Here, I’d bet that Google analyzed growth rates from various kinds of node-addition processes, and found that Facebook is oversaturating its degree distribution and eventually will lose the desirable “near-scale-free” network properties (for propagation), and will tend toward a distribution with too many degree correlations to propagate information efficiently. That’s a complete conjecture on my part, but it’s backed by some solid science on the nature of information transfer on various network topologies.

So Google+ is starting out in a seemingly interesting direction: offering more well-integrated control over how and to whom we communicate, but with a familiar feel and design. The real question now is, will enough people come and play, so that we can figure out how well it works, what Google is *really* doing, and whether that’s good or bad for individuals.

Nope.  Douglas Adams does it every time.  It’s the Golgafrinchans, at the end of Restaurant At the End of the Universe.

Because, of course, they’re us.  They’re our bumbling, over-specialized, incapable of making a living for themselves, useless skills aplenty, useful skills thin on the ground, selves.

And, as an archaeologist and social scientist, the Golgafrinchans always remind me of how fragile our civilization is.  I am a social scientist, and I read a good bit of contemporary social science, of course, but in my work I analyze phenomena at a much longer time scale.  I study societies and social groups as they come and go, are born by fission from some other group of people, flourish, perhaps give rise to social “offspring,” and eventually go extinct.  And what is more emblematic of social extinction than Adams’s portrayal of the Golgafrinchan Ark “B”, carrying the non-essential members of society off to form a new world….

The Golgafrinchans occupy a place in my personal “wax museum of humanity” right next to Danny Hillis’s Long Now Foundation, and their 10,000 year clock.  Although the 24 hour news cycle and the buzz of tweets and instant information would have you believe otherwise, it is over much longer time scales that we can evaluate the success, and equitability, and sustainability of the various ways we humans have, of being human.  Our battles might be fought in days or years or lifetimes, but it is only our descendants that can truly “keep score” and decide how well we did.

The Long Now clock is designed to transcend us as a civilization, and as one of the ways we can communicate some of what we’ve learned with our far-future descendants.  It is designed not to require folks to be close enough to us in time and culture that they can read our writings, or comprehend our ideas, but to draw upon principles that are presumably deeper — not necessarily built into the laws of physics, mind you — but comprehensible to beings who are descended from our kind of minds, our kind of bodies.

Combine the perspective of an anthropologist studying the slow coming and going of societies, and the perspective of a software and systems engineer, and I think you get a sub-genre of futurism and speculation:  what it takes to “recover” the good bits of a civilization, after a collapse or other disaster.  Or simply the slow erosion of deep time.

I think of this problem in algorithmic terms.  If you wanted to maximize the chances of being able to recreate us, down the road after we’ve lost our knowledge, lost this particular set of scientific/democratic values, what is the “minimal instruction set”?

In short, what is the “boot loader” for an open, democratic society  combining expressive freedom and respect for scientific discovery?

This is the closest I can come up with, and I do not claim that it’s a deterministic algorithm.  In other words, starting here, you are not guaranteed to replicate the aspects of our civilization we value.  It’s clearly stochastic, and there’s clearly a lot of noise.  Which means only that I’m giving an “initial condition” and transition probabilities for processes which are in the “basin of attraction” of the product we’re looking for, and that if you follow such rules, “more often than not,” you’d end up with something we’d recognize as an open society.  Assuming you either replicate the experiment a lot (i.e., send LOTS of Golgafrinchans to LOTS of uninhabited worlds), or wait for the experiment to repeat itself over and over (i.e., deep time).

But here’s the algorithm (and I don’t claim full originality here):

1. Pay attention and observe patterns in the world around you, keeping an open mind.
2. Bang the rocks together, so to speak, and make things.  Especially new things.
3. Understand how competition and cooperation work, and why each is necessary.
4. Study those who are different, with an open mind.
5. Pass on what you learn, without too much prejudice.

Put this algorithm on an endless loop, and you have something approximating the progressive parts of the last several thousand years of Western Civilization.   Ignore a couple of key clauses, and you have a much wider array of outcomes.  Not all good, and some downright scary.   Do it just like this, and you might, if you’re lucky, end up with an open, tolerant, prosperous, enlightened democracy.

That’s it.  That’s what it takes.  The Golgafrinchans managed it, apparently…and so did we.  But it was a narrow victory, and the question is whether we can manage to keep it up…..

Happy Towel Day!

Download madsen-lipo-bentley-saa2008-poster.pdf

and will be published soon along with our entire poster session as an issue of the online Journal of Evolutionary and Historical Sciences.  I’ll talk more about this soon, but this week is incredibly busy and I wanted to get at least one link up for the paper before I forget.

I haven’t written much here since late December, but only because life has reached a fever pitch again, and the brief times I have free away from a full schedule need to be devoted to research and my dissertation, not idle contemplation for my website. But we’re in the thick swamp of an election season, unseasonably early of course, and I haven’t written anything about the candidates, the primaries, the debates, as I did for much of 2004. I can’t promise to get back to regular posting before Super Tuesday, but I hope to soon thereafter. Or as soon as I can get my two projects more firmly underway (one paper, one poster) for the SAA (Society for American Archaeology) meetings in late March in Vancouver. Both are co-authored with Alex Bentley and Carl Lipo, and we’re working on the statistical consequences of expressing formal models of cultural transmission within realistic social networks.

For those unfamiliar with cultural transmission, this is the observation that humans are not born with a hard-coded set of cultural behaviors (in the sense of genetically transmitted) but learn, over the course of child development and throughout life, ways of behaving and believing and thinking through interaction with others in our social groups. In a formal sense, cultural transmission is modeled mathematically through analogues of haploid population genetics models (Wright-Fisher and Moran processes), replicator dynamics and allied models from evolutionary game theory, and the contact and voter models in the study of “interacting particle systems” or spatial stochastic processes by probability theorists and statistical physicists. An open question, whose likely answer is “yes,” is that these methods of modeling cultural learning and transmission are formally equivalent, given appropriate variations of population structure and the focus on deterministic versus stochastic models. But more of that in future posts, hopefully.

Basically, I’m working with some collaborators studying models of social learning and communication, for predictive ensemble or spatial statistical “signatures” in cultural data which are mapped spatially and dated temporally. A “signature” would be a unique pattern of statistical properties which tells us how a given population was structured (in terms of social networks) given the results of how cultural information flowed within the population, and came to be reflected in material objects or artifacts. An example would be a model in which we learn about, and adopt, preferences for songs and music from our social network of friends, but in an unbiased fashion — we occasionally adopt the preferences of a colleague or associate. What statistical properties does this local process of imitation have, when projected into a “global” perspective — statistical patterns within a population, spatial patterns in kinds of data we can map and chart?

Of course, we all know that the model I just described is pretty simplistic. Nobody “just copies” their friends, let alone doing so without any filters, biases, and on a strict “coin flip” or probabilistic basis. But it turns out it sure can look that way when you aggregate the results of many people imitating, choosing, learning, and adopting ideas. So this kind of model is a good “null hypothesis” for a simplistic kind of cultural communication — anything more realistic will have to depart from this simple random model in striking, hopefully unique ways.

Being able to find unique, predictive patterns from more complex models of cultural learning and communication is possible, but not guaranteed — it is easily possible (maybe even likely) that several different kinds of social situations could lead to the same overall patterns at a local, regional, or even global level. We call this problem “equifinality” — the data we have are insufficient to distinguish between several possible processes, so given our models and data, each process is “equally likely” to have caused the observed pattern.

This type of research is what I’ve been engaged in for a long time — at least since 1995, with conference papers, publications, and Carl Lipo’s dissertation research covering some of the results. Now I’m extending our previous work and learning a lot of math, probability, and population genetics in the process. It’s fascinating stuff, but in addition to the job at GridNetworks the work keeps me pretty busy.

This is all by way of explanation for my longish absences from writing something here. I hope to remedy that, as I said, but there’s some serious work between now and then.

Today I got a bit of an inkling at a more psychologically adequate answer.  That’s not to say that it’s the "correct," or complete, or the only answer, but I immediately recognized it as a gut-level truth, at least within the scope of my life.  I attended our department’s reception for graduate students and faculty, held at the beginning of the academic year, and met a number of new and returning students, many of whom (because I’ve been off doing business and other things) I’d never met. 

One of the students told me of a class taught the previous year where they’d read a paper I’d written with Carl Lipo (and likely others, I didn’t catch the exact citation, but I’m guessing Lipo et al. 1997).  He mentioned it because of the oddity of actually running into and meeting one of the authors, but for me the experience was significant.  Here was somebody who knew something about me before ever having met me — in this case, how I thought and what I thought about a topic.  He’d encountered some aspect of me as assigned reading in a class, and thus was acquainted with something I’d done and thought, years before. 

We hope to be known, ultimately, by our words and thoughts and ideas.  We hope to be assigned reading, or the fortuitous article or book encountered in the library late one night.  We hope to be the idea that causes somebody else’s project or thoughts to finally "gel" and come together.  Just as others served as the building blocks with which we had a tiny nugget of a new idea, we hope to be the seeds of someone else’s new ideas, down the road.  Most of my ideas and published works will not accomplish this, but some might, whether in a small or large way.

And with that, I greet the new academic year, secure in the knowledge that something I wrote is being read.  And that’s why I, and many others, do research. 

In the first case, the problem was that my friend tried to reinstall XP Pro SP2 over a Dell OEM installation of Windows Media Center, and got an error saying that the product key was invalid. It only took one email for my friend, who’s probably accustomed to folks like me asking seemingly simplistic questions like “did you mistype the code?” to convince me that, indeed, this was a real error. In the second case, a neighbor here on the island knew I was in the software business and asked me why his HP inkjet printer didn’t seem to install and work correctly on his Mac running OS X.

In both cases I was initially stymied. In the second case, I’m still stymied, but I’m buying the guy’s boat so I might help him figure it out tomorrow.

In the first case, a quick Google on the problem revealed that other people have exactly the same problem. Reinstalling a personal (i.e., non-Enterprise) license key for XP Pro over Media Center seems to reject perfectly valid license keys. Of course, even though I worked at Microsoft and have worked with Windows since the 3.1 days, I have absolutely no clue why it does this. I just know enough about the complexity of the Windows code base and have enough anecdotal experience not to be shocked in the slightest. Similarly, I’m not shocked that I could have a serious amount of experience with computers and code and still not have a clue.

I suspect the reason for this is that software engineers actually have two core skills, not one. Sure, software engineers are extremely good at abstraction: the skill of looking at a set of particulars, and creating a model of generalizations to represent any other set of particulars that share all or some of the relationships we imagine to exist within the original case. That task of abstraction is the same one shared by mathematicians, physicists, population geneticists, and other creators of mathematical models. But software engineers, and systems administrators, as opposed to pure computer scientists, have a second skill which is equally crucial. The ability to catalog a large number of actual cases, their causes, and their solutions. In other words, the skill to capture and contextualize and apply the lore of computing.

The first ability, I think, is what people expect when they ask me what might be causing their technology to have a problem. The ability to see a rational abstraction behind the seemingly random behavior that’s occurring, and thus to diagnose what’s wrong. But in reality, the extent of one’s command of lore — of detail, contextualized by situation and software version and architecture — governs one’s ability to solve such problems, particularly remotely — without the computer in question in your hands. The reason is the fundamental complexity of the situation. On top of the hardware runs an operating system, with a specific set of rules. That operating system can be tiny, like MS-DOS 3.3, or utterly massive, like the 60+ million lines of C code that purportedly make up Windows XP. On top of this midgit (or giant), rests a layer of drivers — bit of the operating system contributed typically by hardware vendors that allow the whole thing to work on their hardware. And on top of this three-layer cake runs your applications, today often themselves multi-million line pieces of software code. Code that might also depend critically on being able to communicate to other computers, across a network, to gather data via HTML or other “protocols,” which are essentially small languages that all computers must speak fluently in order to not misunderstand one another.

Complexity is the enemy of things “just working.” And it’s the enemy of even computer professionals being able to understand the systems they build. We can visualize a few interactions; we can even visualize a few histories of interactions. But nobody can visualize all of the interactions and possible states that even a moderately large piece of software (forget Microsoft Office, Windows, the Linux kernel, or Mac OS X) can display. Heck, human beings can’t visualize the geometry of a vector with more than three dimensions! How are we possibly going to understand the state space (i.e., possible behavior) of a piece of software with 66 million lines of code and megabytes of internal state variables?

We can’t, in detail. We do so statistically. We test things over partial ranges of their possible behaviors. Hopefully the important range of their behaviors, in terms of how often users can get their system into the same state. Even understanding the scope of the range of possible behaviors is a massive challenge, witnessed by the continued research into code coverage, automated testing, and the like. The current popularity of unit testing probably represents a programmer-driven effort to simply reduce the dimensionality of the state space. Unit testing reduces, by pursuing automated means of verifying the lowest level of “contracts” within the software itself, the size of the state space by large factors.

But what’s left after good, serious modern testing and QA is still a lot of possible behavior, and only some key pathways, the deepest, most intentional valleys through the overall “landscape” of behaviors, are documented or recorded. Much of the state space of a modern commercial software program is still deeply terra incognita, as a simple consequence of the overall complexity and coupling present in our systems.

Thus, I was encouraged by this post about Erlang on Lambda the Ultimate, a prominent blog about programming languages and the associated computer science. The designer of Erlang, Joe Armstrong, has this to say:

The Erlang flagship project (built by Ericsson, the Swedish telecom company) is the AXD301. This has over 2 million lines of Erlang.

The AXD301 has achieved a NINE nines reliability (yes, you read that right, 99.9999999%). Let’s put this in context: 5 nines is reckoned to be good (5.2 minutes of downtime/year). 7 nines almost unachievable … but we did 9.

Why is this? No shared state, plus a sophisticated error recovery model. You can read all the details in my PhD thesis.

Interesting. And impressive. It’s possible that there’s an approach here for reducing complexity to manageable, understandable, plannable levels. Objects, aspects, and other recent software innovations aim to reduce dimensionality, allowing more of the total state of a program to be explicitly designed, rather than showing up as emergent run-time behavior.

It seems clear, though, that getting a handle on complexity in software is critical — if we’re going to be able to diagnose what goes on inside our software, and thus if we’re going to be able to trust it. For commerce. For security. For privacy. And for exercising our rights in a democracy, since more and more, software is involved when we vote and make decisions.

I attempted mathematics, and even went during the summer of 1828 with a private tutor (a very dull man) to Barmouth, but I got on very slowly.  The work was repugnant to me, chiefly from my not being able to see any meaning in the early steps of algebra.  This impatience was very foolish, and in after years I have deeply regretted that I did not proceed far enough at least to understand something of the great leading principles of mathematics, for men thus endowed seem to have an extra sense.

Precisely.  Studying the evolution of culture and cultural behavior, from a modern Darwinian perspective, is inherently a mathematical business.  Change is modeled as shifts in the frequencies of behaviors or traits, rather than outright transformations.  And this means that calculus, linear algebra, differential equations, and stochastic processes are critical tools.  Just as you wouldn’t hire a carpenter that knew how to build a cabinet, but didn’t have the tools to do the work, it’s hard to be an active researcher in this field and not have the right tools. 

So I’m reviewing, practicing, and going further than my previous education in math, and I’m enjoying it thoroughly.  I find that I’m one of those people that needs a purpose and a reason to learn things like the more abstract bits of math, and once I have a good reason, it seems to go smoothly.  But it’s also time-consuming, and it keeps me from writing more.  I thought I’d explain in case y’all wondered why I’ve been quieter than usual.

A paper by Railsbeck et al., in the September 2006 issue of Simulation, is right on the money in saying that the original Objective-C version of the Swarm toolkit is a strong “framework,” as opposed to the “library” style of successor toolkits like RepastJ and MASON. Swarm definitely forced a style of organization onto your simulation models, via the concept of nested “swarms” of agents, observers, etc. I suspect this is much like Ascape, but the latter doesn’t seem to be an active development project any longer (at least given the website – leave a comment if this incorrect). Whereas Repast provides a ton of infrastructure but simulation models themselves seem to be fairly unstructured, as I read various examples and models folks have posted online.

One of the reasons it’s hard to create a generic framework for computational models is that they differ in structure and needs across domains. On the other hand, within a specific research domain, it seems like structure should be relatively standardized, particularly if we want to communicate, share, and replicate results. So the governing philosophy I’ve been using with TransmissionLab is that of a domain-specific standard modeling framework built on a standard generic toolkit, tailored to the research needs of a given domain (in this case heritability/genetics/cultural transmission modeling), but flexible enough to allow the building of many models by different groups of researchers. We’ll see how this works out, but it seems like a good “middle” approach to the problem.

Version 1.4 of TransmissionLab is a reasonable step in that direction. Nearly all of the “boilerplate” involved in building a computational model is abstracted into a series of Java interfaces and abstract classes (which provide templated partial implementations for the interfaces). All of the “machinery” of the simulation deal exclusively with interfaces, such that nearly anything that the “user” writes can be considered a reusable component. For example, in the rules package, TransmissionLab currently includes a rule for “mutation” called RandomAgentInfiniteAllelesMutation. Assuming that “traits” are being represented as integer “tags” (a generalization of this will be in a future version to allow Object traits with internal structure), this rule will operate on any implementing class of the interface IAgentPopulation. This allows a simulation author to reuse this mutation rule, creating populations that are well-mixed, spatially structured, network-structured, and so on.

The central model class (which contains the “main” method, for example) is similarly templated. The “component” classes (rules, data collectors, population factories) all work with classes which implement ISimulationModel. In practice, main model classes extend the abstract class AbstractTLModel, which provides full or partial (template method pattern) implementations of the ISimulationModel interface contract. By design, satisfying the ISimulationModel contract also guarantees that your model class meets the needs of the SimModel contract in Repast, and thus will be runnable by any standard Repast method. But since much of this “infrastructure” is contained in the abstract base class, user-written model classes are much much simpler. In fact, looking at the new implementation of the Random Copying Model this morning (class NeutralCTModel), it strikes me that everything in it could be specified declaratively, in an XML configuration file. So I may get to the point soon where user-written models are just XML files, users write new components as Java classes, and the framework stitches together the rest.

All of this may sound suspiciously like Repast Simphony, so why I am putting in this work?

Several reasons. Simphony is still alpha code, and although it’s coming along very nicely, I’m not yet sure what I think of it as a modeling framework. Clearly many of the goals are the same as I’m discussing here, and I may port TransmissionLab to Simphony down the road.

But Simphony is a bit of a “black box” at the moment: I’m not quite sure how it all works under the hood, and that bothers me. Exploratory simulations are fine if I don’t understand the fine detail of the runtime, but if we’re going to be sure that we’re getting scientifically usable results out of a computational model, we’d better darned well know exactly how the model works, period. This is the problem I have with NetLogo (other than proprietariness and the fact that it’s well suited to specific types of models, not generic simulation).

So I’m still working with RepastJ, and plan to continue doing so until there’s a compelling case to switch. And working with RepastJ is a lot simpler if you have just a bit more structure. So TransmissionLab will continue to evolve in the direction of a domain-specific modeling framework using RepastJ. If you’re doing simulations of cultural communication and transmission phenomena, check it out.

Both the batch-mode parameter file and library dependencies have slight differences from Version 1.2, so be sure to grab both otherwise you’ll encounter errors starting up a simulation. In particular, this release adds a dependency upon the Jakarta Commons CLI library for command-line parsing, since this isn’t a strong suit of the Repast libraries.

This version also adds one statistic to the OverallStatisticsRecorder data collection module. For each simulation run, we calculate the average number of agents who have traits (measured at each model tick) which are listed in the “top N” list of traits. In other words, if you’re working with a “top 40″ list of song-analogues, this statistic measures the number of agents whose chosen trait is a song in the top 40, as opposed to a trait that wasn’t frequent enough to make the top 40 list. This statistic is thus paired analytically with the parameter for the size of the “top N” lists, and the combination of the two should be interesting to examine across a range of mutation rate and population size parameters.

On a related note, LiveScience has an article on the upcoming article by Alex Bentley, Carl Lipo, Harold Herzog, and Matthew Hahn. I recommend it for a somewhat popularized account of the main conclusions of their 2007 paper. Since much of what we’re doing with TransmissionLab at the moment is going further along the lines suggested by Bentley et al., and earlier Fraser Neiman, Carl Lipo, and myself, it’s a good clue to the kinds of phenomena we can explore purely assuming that choice among alternatives is statistically random or neutral.

I’ve been busy on the simulation modeling front this week, coming out with a “final” version of the RandomCopyModel from an upcoming paper by Alex Bentley, Carl Lipo, Harold Herzog, and Matthew Hahn. I didn’t work on the original model or paper, but Alex graciously allowed me to use the original code as the basis for some future experimental models we’re working on, as well as simulation setups I’ll need for my dissertation research. In return I refactored and made the original simulation a bit clearer to follow in terms of the code, so we’re providing version 1.3 of the RandomCopyModel under the terms of a Creative Commons-GPL license for non-commercial use.

In the meantime, I’ve also been planning the next “version” of the model, which is now a separate codebase managed by Google Code under the name TransmissionLab.

The goal of TransmissionLab is to accurately represent theoretical models of CT (e.g., random copying, prestige-biased transmission, frequency-biased transmission) within a variety of population structures (e.g., complete graphs/well-mixed, sparse random graphs and social networks of varying topologies, spatial lattices), and using a variety of update algorithms (e.g., Moran processes, Wright-Fisher processes, various other birth-death processes). TransmissionLab seeks to also make data collection and “observation” of simulated populations simple, with modules which are completely separate from the simulated population itself thus preventing observational “side-effects” on the model. Analysis flows from data collection, and can be done in a variety of ways.

Naturally we’re not the first people by any means to do agent-based simulation models of cultural transmission, imitation behavior within populations, or the diffusion of innovations. Heck, this isn’t even the first simulation of these sorts of phenomena I’ve been involved with. Where I hope that TransmissionLab differs is that nearly all of my previous simulation models have proven fairly special-purpose, expedient models for working on one particular question or problem, and I’m trying to make TransmissionLab a common platform that can span projects both for myself and my research group.

This is important for a number of reasons:

1. Stable, well-used models tend to be well-structured, well-tested models. The issues of whether the simulation is showing us artifacts of writing software or the theoretical behavior we’re trying to describe can only be solved by deep investment in design, coding, and testing.
2. Relating the results of one study to another when each uses different simulation code is a difficult one, for obvious reasons. To the extent that we use the same code framework and models to perform multiple studies, we can make arguments (and even measurements) which relate the results of several research studies to each other.
3. The relationship issue mentioned in the previous item could span multiple research teams if the model is well-structured and tested enough that others adopt it for research.

Thus, I’m putting some reasonable effort into developing TransmissionLab, and if you have an interest in agent-based modeling and cultural phenomena, I hope you give it a look in a version or two. Right now I’m moving from the older RandomCopyModel to a new set of development tasks, which will be outlined shortly at the googlecode wiki for the project. Once these are checked in, there will be some interesting elements beyond the earlier model to explore. I’ll post when that happens.