Software has some powerful attributes, it’s part of the reason I love working in the industry – just one person and a computer can build and share a tool with billions of people in a matter of moments. The optimistic view of this is that its enabling – software can have profound positive effects on the world, almost instantly. It can empower the disempowered, improve the quality of life for people who would otherwise not have that opportunity, it can unlock access, equality, and justice.
Of course, it could do the opposite, too.
And so we find ourselves stuck in this game. Software companies, driven by their commitment to shareholders to generate profit, release the tools at scale that help them deliver on their shareholder commitments. They ‘push us forward’. They ‘help us progress’ as culture. They ‘disrupt the status quo’ because the old way isn’t necessarily the good way, in fact, the assumption is that it most likely isn’t the good way.
So the good software spreads. It creates opportunity as promised. It helps more people participate in the economy as promised. It drives up profits as promised. It unlocks value that, until now, was impossible to activate. It changes the culture through saturation and suddenly those affected can’t imagine a world without it.
As the culture changes, software can respond quickly. In fact, that’s the mantra – move fast and break things. Ship it. Measure the effect. Sense what’s needed next, then make that. The build – measure – learn loop that’s so prolific in software development means that, in a matter of months, several iterations of the tool can be refined, honed and released to meet the needs and demands of the consumers who are using the tool. Often the first thing that was shipped morphs, through feedback, to solve a vastly different problem for a vastly different audience, but who’s keeping track of that when all that matters is the promise made to the shareholders – people will pay for this problem to go away, so now we’re doing that.
Have you ever seen a toddler learn to walk? That’s software. One step after another, learning as they go, gathering balance and momentum quickly. The destination is uncertain, in fact, in most cases, completely unknown, but the mantra is forward without falling. Just keep going. That is, until the parent pulls on the harness and re-directs that energy somewhere else – enter regulation.
Iterative regulation isn’t possible
Everyone knows that regulation, compared to software, is slow. But that’s because laws can’t work like software. In fact, it’s culturally agreed that they shouldn’t. Laws are deliberate, long-lasting, and need clear definitions and boundaries. It would be completely impractical to change the definition of Murder or Grand Theft Auto every few months. Good law-making requires deliberation, long-term analysis, science, political engagement. Issues of equity & justice are central to law-making which makes that deep consideration necessary – once a law is passed, people’s lives and choices change. There is no room for misinterpretation and so the language used in law does its best to articulate its meaning as clearly as possible.
But, like with most things, it’s never perfect. Ask two lawyers to interpret the same paragraph of law and both with come away with opposing viewpoints – the defendant and the prosecutor. The laws we write cannot be divorced from the cultural and political moments in which they’re written. And, similarly, their interpretation, many many years later are also influenced by the moment in which they’re interpreted.
Technological Social Responsibility over Corporate Governance
If it’s impossible for regulation to be iterative, and software, by its nature, is, then who is better placed to ensure that some of the role of regulation be woven into the process of designing, building and distributing software at scale? Maybe software companies could play a role in ensuring that issues of equity and justice, those things normally considered central to law-making, are considered alongside profits and innovation. Maybe the additional constraint will unlock even further innovation (as constraint often does) – not a world we know is possible, but one we can’t even imagine until we do it.
It’s the funny thing about software people – so quick to criticise the government, public policy, ‘slow-moving’ institutions. The culture is one of disruption; cause a ruckus then deal with the consequences a few years down the track when regulation inevitably (and often poorly) catches up. Uber, AirBnB, and now Buy Now Pay Later software are just a few examples of software’s inherent nature of disruption – the hare running ahead of the tortoise.
If I looked at regulation like a software person I’d see an opportunity. Not an opportunity to ‘get around regulation’ as is the default thinking I’ve experienced in the industry, but as a possibility of creating a fairer, more ethical, more just world more quickly. And, to be clear, I’m not advocating for corporate governance, but rather Technological Social Responsibility (TSR) – a consideration that those who can provide tools to billions of people overnight not only should consider their longer-term socio-political implications, but must.
What needs to change in software?
Like addressing any deep cultural assumption – e.g. women shouldn’t vote, gay people can’t get married, segregation – the idea within software cultures that software companies could do a better job at uncovering and planning for longer-term detrimental effects of their software is, at the moment, a radical idea.
Whenever I float the idea of TSR to software companies it’s met with immediate, knee-jerk responses like, “That’s the role of regulation!” Even though we all know, implicitly, that what that response really means is, “We want unfettered access to scale and impact because we see a business opportunity. And, if our hunch is right, we’ll be well and truly scaled and profitable before regulation has time to catch up. By that time, we’ll have a significant amount of power and money that will help us shape or defend ourselves against it when the time comes.” It seems that software companies want to disrupt everything but themselves.
But, this is the thing I don’t understand about software people: we are so good at thinking about complex domains and systems. Engineers are literally trained to think through risky scenarios and draw out all the thing that could go wrong in their code. We think through edge cases and what-ifs all the time. The only difference is scope – it’s just that we’re not applying this incredible analytical and logical skill to the broader cultural implications of giving tools to millions of people in the space of days, instead we’re checking it against the effect on revenue, monthly active users, retention, acquisition, and engagement.
It’s not as if tools to help us think through these complex implications don’t exist. Regulation has a version of them already and whilst they aren’t perfect, and they probably take longer than we would like, they’re better than nothing. They also present an opportunity for incredible software thinkers to ‘disrupt’ that and design or uncover ways to make that process better.
And, as the world begins to realise the ecological impact of software at scale, new and interesting tools are emerging all the time to help us think more long-term, beyond tomorrow, at an intergenerational and global ecological level.
So, if it’s not for lack of access or availability to these tools, it’s something else. But, like with most things, the barriers to change are based on a deeply held, almost invisible assumption – that we can’t have social responsibility and profit, scale, & power. We also used to think that staying at strangers’ houses, getting a ride from someone you’ve never met, or transferring electronic money from person to person were things we couldn’t have – but here we are.
Reframing the idea of legacy software
Unlike landfill, the legacy that software leaves behind doesn’t visibly pile up (although there is the ecological cost of the raw materials that require us to live in this digital age). Software changes the very thing we cannot always see immediately and struggle to anticipate unless we put a concerted effort towards it – the relationships between things: humans and things, humans and humans, humans and animals, humans and our planet. When those relationships shift, it’s far easier to label it an abstract phrase like ‘the evolving cultural landscape’ and do what software and toolmakers have always done – create something new to deal with the problem that the first thing created. The cycle only speeds up – the more tools, the more unanticipated problems, the more tools we need to handle them.
Software leaves behind the things we struggle the most to measure – the relationships between us
Design, as a practice, seems uniquely placed to help engineers, product managers, and businesses visualise and understand the relationships between things. It’s something we take for granted – a skill that seems so obvious that we struggle to understand why others aren’t doing it (just like ‘listening to the customer’ was about 10 years ago). As Paul Rand so famously said – Design, in its truest form, is nothing but understanding relationships.
And so what if legacy software was thought about like a city or a public garden? Infrastructure with a 20-30 year impact – or even longer? What if it was normal for the planners & builders of software tools and systems to know that they’re working on something that they may not live to see others enjoy but do it anyway? Stuff that doesn’t just improve their lives or the lives of those with access to the internet, but for generations that don’t yet exist?
Sure, the technology that we build these systems on will change, evolve, and unlock new opportunities but perhaps the relationships that software creates between humans and the planet could persist or evolve with more intention?
Yes, there are positive and negatives to any tool that’s provided to the masses, any technology that’s created to solve one problem often creates another. But, perhaps if we were more concerned with what us software makers leave behind in the long term rather than the short-term thinking that’s so pervasive in software-building cultures, we’d start to shift the needle for how software thinkers begin to plan the way they disrupt or change the culture. To borrow a little thinking from Regulators, those slow-moving curmudgeonly lawmakers, we may find ourselves iterating our way to a fairer, more equitable world and leaving less people behind as we go, even as the culture evolves.