code and the oracular

Debugging Social Software

leave a comment »

In this piece I will rap briefly about the idea that social institutions and patterns are essentially a form of software and as such can thus be seen as something that can be debugged.

As geeks take over the world, many of us seem to be turning to various forms of political radicalism, espousing libertarian ideals and particularly freedom of speech and information. Is it a helpful image to think of reformers like Gandhi or Mandela as genius authors of new kinds of social software? Software because human institutions follow rules, software because our brains and behaviours are partly computational. Law itself is about rules, and legal or political thinking is just another application of logic. Government is about distributed systems that also follow rules and systematic behaviour. Even the innovations of avatars and prophets in religion are simply software innovation.

I assert that any of the following can be debugged:

  • economics
  • education
  • government
  • healthcare
  • international relations
  • industry
  • the environment
  • the family
  • the self

and many more. Art too can be helpfully viewed as software because like all the above it has users with needs, developers and a design strategy and purpose. The wetware of the brain is practically infinite, and this is what draws artists to their chosen forms, but if art is information then I hold that the analogy is good. Art criticism is commentary upon a kind of information, its behaviour and the trajectory through immense spaces that the data follows as it enters our minds and explodes in the multiple reflections of shared consciousness. Art history is the story of innovation in a software that programs our minds aesthetically. Social and political history is the story of new development in a technology that regulates and orders nearly all human activity.

So if these things can be debugged can they be changed? That’s a perennial question to most people. If the fossilised strata of social order is so often resistant to change then your suggested fixes may not be implemented easily. But there is often a chance that you can mirror or model the institutions concerned in a personal sandbox to aid your experimentation. That’s just thinking and planning.

What government, healthcare, education and others do is to create a large distributed software system that aims to solve a set of problems or needs. There are many kludgey parts of systems like this that even beginner social devs could raise an issue about. These kinds of system tend to achieve a saving on space and time complexity by grossly averaging models of their users. All humans are in some capacity round pegs in square holes and many grievances with large organisations come when the averaging process, implemented to save resources, fails to model an individual or group with sufficient richness to honour their need for rights and recognition.

Computers have to assist in creating richer and more effective systems, otherwise what have they really done for humanity? This worldwide revolution is only just beginning, with Arab Springs and Occupy, with social networks connecting us, with campaigning organisations and the iterative improvement of democratic systems (and occasional dis-improvement too.) And it all benefits from the software metaphor. Good code has to be readable, and our institutions in human society likewise. Good code has to be tested, written with style, fast and memory efficient… all these aspects transform in this metaphor over to social structures.

Seasteading and startup countries show that users will want to migrate to social groupings that function better, or are more tailored to their specific needs.

fixing bugs around you

Many of the authors of social software are dead. If there ever was an author, that is. In other cases the effective author was time and evolution. Of course I should add that mere evolution does not necessarily imply the optimisation steadily over time that we call progress.

Sometimes you will not be granted access to the system you are wanting to debug. This itself is a major barrier to the improvement of social code. If secrecy is involved such as with areas of defense policy, then it may seem more likely that the social code involved is obfuscated and highly buggy. You can petition the admins of the system for access if you decide you want to debug voluntarily, and we see this happening increasingly round the world. The admins may not take kindly to it, as individuals such as Assange and Snowden have found. But the more this happens the more chance everyone has to see that crucial areas of human affairs would benefit greatly if some basic rewrites and tidying up of code were done.

In your personal systems where it might be true that you have code ownership, you can have a freer rein to debug and improve the functioning of your own small individual sphere. Sometimes though the fact that you have done some work at personal debugging may lead to discordance with the social agents and systems around you in the world. In worse cases you may be ostracised or even harmed. Some people establish groups linked by common interest in order to be able to debug self with less fear of discordance. In some cases the wider society will persecute or try to undermine these kinds of groups, while in others the movement may spread and your bugfixes become part of the trusted kernel of the wider world.

progress and social debugging

Because evolution is not always progress but often a meandering path around a fitness landscape, the best summary of the majority of social systems could even be “Things are the way they are because they got that way”. This statement encapsulates the illusion that later or more modern is better, when the true and time tested ways to assess the real performance of any kind of code are already being established among developers and testers. Any useful way of assessing social code can be used to highlight failings and propose iterative improvement, so badly needed in a world of conflict and oppression stemming mainly from bad social code implemented by incompetent and morally blind legacy developers.

Each personal threat that looks like coming to you as a result of your debugging activities should be weighted based on two variables: the degree of confidence you have in your perception of the threat and the extent of the damage to self it would cause if it was executed. When the risk is modeled carefully for all your activities you can decide whether the possible optimisations are worth the degree of damage you expect. This might be called “having priorities”.

If the threat from your knowledge work on social structures escalates beyond a certain level then you should consider sharing your findings and situation wiyh your peers as soon as possible. This is because of the arduous nature of social debugging, and the way risks of alienation increase according to the proximity of systems to your essential self core. In some cases Human Rights may protect you and your team, and we of course see this happening quite widely in the present day. Solidarity among social debuggers is so important because the tendency of anti-progressive forces (who want to keep code inefficient and obfuscated) to silence the individual is well-known. You have strength in a team and of course you can increase the efficiency of your team by developing an appropriate methodology for your shared work. All traditional development methodologies have strengths and weaknesses that still apply when the development task is for social software rather than ordinary computer code.

development teams

If you are without a team the job is much harder because you risk isolation and discordance with the reality of others around you. Madness is often a consequence of serious debugging work that has shown promise but that has carried the developer too far beyond the limitations of society in her region. To be sane in a mad world is to be mad in the eyes of the so-called sane who surround you. You must not isolate because the agents of inefficiency who are so averse to the exposure of their bad code and poor methods use isolation as a tactic to silence talented debuggers.

If, during the debugging process you uncover a bug that has been causing damaging outcomes, then you may risk ethical problems if you fail to fix it as soon as you can. This is different to morally neutral debugging of ordinary computer code because it involves a need to show “moral courage”. It is only reasonable to seek out the views of your peers in this, again for extra problem solving capacity, but also because no man is an island and debugging systems like war which involve death and pain is the hardest work a social developer can do.

You may indeed find that the current state of most human social software, as embodied in tradition, law and social structure is so poor that you have taken on a larger job remit than you initially though. This again is a known scenario, and each developer will make his or her own bargain with the fates about their relationship with the world they live in. It is up to you how much you attempt to optimise, some do so little, other great radicals and world changers have made fixes that still rock human reality. The overall effectiveness of social software across the planet is a cosmic issue, with so much bloodshed and destruction at risk.

But if you can see what equality, fairness and human rights really means for social code, and the huge benefits of systemic effectiveness upon all humans, then you will obtain a great motivation that will bolster you and even protect you in your career as a social debugger. I wish you luck.

debugging the self

the most intimate regions are inside your own self. Much of psychology, psychoanalysis and psychotherapy is about debugging and optimising this most personal kind of code. Freud claimed that his method produced great efficiency benefits for humans, and many other thinkers have followed since then. There are risks of madness and suffering here though. A sandbox is useful when changes in mental code would otherwise be irreversible. The unweaving of complexes and neurotic code is also something that the new wave of humans are performing more than ever.

finally: debugging this article

What I have hoped to offer here is a metaphor that I have been nurturing for a while now. As simply a metaphor it is a very fuzzy form of code that is designed to inspire and stimulate the imagination and intuition. It may not even be code but rather some notes towards improving my own social developer’s methodology. I haven’t come across anyone else who is using this metaphor so I proffer it here with thanks for your time and personal system resources.


Written by Luke Dunn

January 18, 2014 at 8:01 am

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: