Attribution in technical projects is a fascinating topic. Fascinating, important and very occasionally controversial. Who should get credit for a work? That developers get attributed for the code they create is generally non-controversial. One, fairly typical, way to do this is to document these contributions in the copyright and contributions file of an open source project. You can also, of course, look at any given repository and see who has added what over the course of a project. It all seems pretty clear cut.
But what of the other people involved? Those that make wireframes for example? High level systems architects? Project or product managers? Ideas people? Founders? Designers? These people do not contribute code, so where do we place attribution for their work?
Generally speaking, the acknowledgement of these contributions occurs in places other than the code. How should we tell the story of the other people involved and what are the appropriate tools to do this?
These stories don’t often get told. When they do, they are in narrative form, on websites or blogs, telling the personal or organisational journey that saw a software from idea to reality. But unlike the contributions files and history records in code repositories, blogs and websites have a much shorter lifecycle and are bound, sooner or later, to be lost. Those stories tend to fade, leaving just the record of the code to tell the story.
It is a pity, because many of these contributions are critical in the life cycle of any software. Where would any successful desktop software be without the contributions of user testers? Many software solutions would not get a second look without a designer’s touch or feedback. Some projects would never have been born if it wasn’t for the inspiration of some energetic soul who managed to convince others of the value of an idea.
I’ll use my own work as an example but the phenomenon is bigger and there are far too many folk whose contributions go unacknowledged.
In a career, I’ve been fortunate to work on many successful and interesting technical projects over almost 2 decades. I have often been the ideas guy, not a developer, not a designer. I suck at QA, but I major in musing on the possibilities that technology can offer and I have become better and better at opening up people’s minds, from developers to clients, to funders, to what is possible. It is a process of inspiring and convincing others, of finding ways to gather momentum and resources to propel people down a promising path.
Sometimes I am fortunate to be credited for this work and I cherish those few moments where people have recognised this contribution and credit me. It doesn’t happen often, but it does happen in the occasional blog. Martin P Eve for example, a good friend and all round solid guy, called me out recently in a post about his JavaScript Typesetting Engine CaSSius:
“I can’t remember when Adam Hyde first suggested to me that CSS regions might be a viable way to produce PDFs for scholarly communications but it seemed like a good idea at that time and, I think, it still does. CaSSius is my implementation of that idea.” https://www.pagedmedia.org/cassius-heavyweight-typesetting-with-lightweight-technology/
It was very generous of him to do so. Without this, there would be no other record of my affect on his thinking and practice. I was humbled by his generosity.
When these things happen, while rare, it motivates people like me. It puts some fuel in our engines to keep moving on and continuing to work the way we do.
Sometimes, however, it goes the other way. Occasionally, and once again (thankfully this time) it is rare, there are those that believe we should not be credited. Having managed many projects, I actually understand why some people do not see the value of this kind of contribution, as Lao Tzu is credited with saying:
“When the best leader’s work is done the people say, ‘We did it ourselves.'”
Management and leadership are strange arts, and often lead to strange paradoxes. I have often found myself invisible in credits while generously crediting others. Once or twice someone has been outraged when I casually mention my involvement in a project that I managed, initiated or inspired.
These moments are rare and curious, especially when they involve small projects that represent not much more than a line item in my career over several decades involving many innovative approaches to many interesting problems. I guess over time I have come to understand that for someone the line item is the source of great pride. This may be the only innovative project he or she has ever worked on. While I’ve begun to understand it, this kind of proprietariness doesn’t make a whole lot of sense in the open source world – it plays better in an all-rights-reserved world.
But even when things are this weird, I will continue to shine the light on their work and attribute them, despite the lack of reciprocity. Credit where credit is due, even if attribution is, unfortunately, a one-way street at times.
The good news is that many open source projects do attribute many types of work. Mozilla, for example, has a single global credits list where names are recorded of people that have made “a significant investment of time, with useful results, into Mozilla project-governed activities.” Audacity is a favorite project of mine that credits pretty widely, categorizing contributions to include code, documentation, translation, QA, administration etc. These are great examples of software projects recognising and honouring a variety of work. We should all follow these examples, Open Source can only benefit from the generosity of attribution illustrated by these projects.
As a coda, and on reflection, I think we need to think carefully about how work is valued and attributed in technical projects. Architects often proudly say “I built that house.” Did they actually lift the hammer and cut the wood? Probably not, but I think they have a right to proudly state their contribution as much as user testers, designers, developers, managers, QA folk, and ideas people have a right to state and be recognised for the contribution they made towards a software. Not only that, we should all celebrate and recognise the large variety of contributions that goes into making software and find effective, lasting, ways to tell those stories.
