On software development, language games, tech adoption and the death of the author

One of the founding principles of RedMonk is that we don’t try and define terminology for the tech industry to use. Where a good term exists, or is being worked out, we’ll use that. It is our role to describe and package the way people talk about processes and technology, rather than try and define it. Things to do in the analyst business when you’re dead. I would go further though and argue that any attempt by us or anyone else to define terms is doomed to failure. Language is dynamic, fresh and ever-changing, and with the rise of social media it has become more so, rather than less.

Far smarter people than us worked this out long ago. There is no “essence” of meaning when we describe things or objects. Any attempt to define the essence of things is doomed to failure. Rather language maps to the world in playful, mutable ways. As Wittgenstein argued in the Philosophical Investigations: “the meaning of a word is its use in the language”, or ” the meaning of a word is its use”.

When I see technologists complain that a term is being incorrectly I generally think of Wittgenstein. Do we really believe there is some one to one mapping between an idea and the object it represents? Is there some essence of “node” we can capture and define? Of course it shouldn’t surprise us that folks involved in software engineering would tend to prefer that there is a single truth we can cling to when using a word. But that is not how the world works. Unlike software, the stuff we say and write about software doesn’t need to compile.

Consider “threads“, for example. According to Wikipedia:

“In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system”

Then software people started describing online conversations as “threaded”. Today on Twitter we say, approvingly, “Thread!” Everyone knows what we mean. Should we complain that “no!, that’s not what “thread” means. We already have a meaning for that.” Of course not – the meaning of  “thread” is its use in the language. Humans are very comfortable with ambiguity – it is essential in rhetoric, poetry and by extension human communication – see William Empson.

In The Stories of English David Crystal explains how English evolved, how it is still in a state of evolution, and why any attempt to pour concrete on it is always doomed to failure. Samuel Johnson compiled a great dictionary, but that could never be the final word on the English language. Because language is a living thing. Science is today the biggest source of new words in English. Are we really to believe we could pour concrete on a set of tech terms – node, mesh, thread, DevOps, and see them applicable for ever more?

Twitter is perhaps the greatest petri dish for language ever created. We adopt language faster than we ever have before, and one of the prime sources of new language is tech. The interplay between our industry and the wider culture has accelerated. We should celebrate this dialectic.

One argument I saw this week was that we need to pay attention to the intentions of somebody that came up with a term. We might as well expect people to only use a technology for the thing it was originally designed for. Not going to happen. People are going to keep using message queues as caches and caches as databases and databases as distributed logs. All the boundaries are fluid in the technology, let alone the language we use to describe it.

The author’s intention really doesn’t matter. Do we need to know Jesse James Garrett’s intentions in order to get value out of Ajax? No – Ajax just gave it a name, and we all moved forward. Our what about REST? Roy Fielding helped drive the state of the art forward, but it makes no sense to worry whether or not he’d approve of our API when we expose a new endpoint.

So this happened

bit sad https://t.co/81ZsyMoxyJ is a 404

— Grumble Bundle (@monkchips) November 1, 2017

The Death of the Author was an extremely influential essay in literary criticism by Roland Barthes. It argues that the author’s background is not essential to understand a work – rather we can bring a diversity of critique to a piece without recourse to the situation of an author when she created the work in question. I should say I am as fond of IT history as the next person – we do have creators and individuals that have an outsize influence on the work we do. Clearly Linus Torvald’s intent matters when it comes to operating system progress. Salvatore Sanfilippo’s design decisions matter for Redis users. But we don’t need to understand their intentions in order to use their works.

We should make a distinction though between code and how we talk about it. Tech is a fashion business as much as an engineering discipline, and thrives on froth and excitement as much as “substance”. There is no essence of technical terminology – only how it’s used between communities of practice and interest.

We should beware the Cathedral, and the Canon, not least because churches have a marked tendency to exclude voices. The tech industry future I want is defined by being more inclusive to ideas from folks like Charity Majors and Cindy Sridharan, bringing new perspectives to Observability, or Jessie Frazelle and Liz Rice on container security, or Nicole Forsgren and Bridget Kromhout on DevOps.

Nobody owns the ideas we use. Nobody owns their meaning. Language is playful, it’s going to change, and that’s a good thing.

Much of this post was inspired by interesting thoughts from Gareth Rushgrove and Sam Newman. I don’t really agree with them about nailing down standard definitions for things.