An ethical new age for technology

One of the biggest challenges to my digital practise of late has been a creeping cynicism I’ve been feeling. It’s hard not to really. The excitement and promise of an open, accessible technology enabled future is something that I’ve been inspired by since the first time I snuck onto Prestel as a child. It’s why I pursued a career in the digital industries, and why I have spent most of that career advocating for it. Yet it’s increasingly beginning to feel like we’re in the bad future – that we’ve gone William Gibson instead of Arthur C Clarke. Powerful corporate technocracies, ever distant remote controlled wars, a media which is struggling to monetise and is therefore diminishing it’s own core values, and of course the post Snowden realisation that we’re not paranoid, we’re not over-stating it, there really is a huge structural system of surveillance which is beyond the dreams of Orwell. It’s a sobering time, and so I been finding that, for the first time in years, I haven’t leapt on the Gartner futures list or excitedly watched TED talks.

That is, until I saw Aral Balkan’s article on ethical digital design, and watched his (superb as always) talks on the subject. I’m not going to understate this, I think this is the most important thing that I have read about Being Digital since Negroponte.

I’ll leave the manifesto to speak for itself, and there is good debate around it’s points happening elsewhere. What I would like to focus on in this post, however, is the response from technology to this challenging and liberating ethos. When I read this manifesto, and in particularly the Maslow-style hierarchy of user needs, I excitedly forwarded it on to various networks, including an internal technology team here. There was a good response from the UX and design departments, those that are traditionally focussed on user needs as much as the brands. From the developers though, barely a peep.

This is a problem.

The experiences which we create for people to use are ultimately built in a technical stack, and for far too long, developers have focussed entirely on the technology itself. In fact with the front-end technology stack becoming ever more immersed in software engineering practises with the rise of Node, React et al, I am concerned that this is becoming more and more the case. The traditional ‘unicorn’ client-side developer used to be one that bridged the gap between design, UX and development. More than ever, it’s one that works across the full technology stack. This is good for technology, but bad for our users. I’ve already been witness to long discussions about technical design which utterly ignore what we’re actually trying to achieve for the people of the world that will consume these experiences.

If the vision of the ethical design manifesto and it’s human-centricity is to be realised, then it is vital that key figures within the front end technology community start to talk a lot more about their end user, and (slightly) less about the virtues of functional programming versus classical inheritance.

Those of us working with technology for a better end user experience are working in a golden age of frameworks, tooling and techniques. It is a huge mistake to think of the ethical design manifesto as only being a strategic, design or experience solution. It lies at the absolute core of what we are actually trying to achieve when we build websites, apps or other digital products. Even with regard to middle-ware or service layers there are lessons that can be learnt from this approach, for instance, in the design of your micro-service suite in alignment with the needs of the users rather than the needs of the application or architecture.

In short, we need to be just as excited about this stuff as our design, strategy and UX driven colleagues and I really hope that we see some traction amongst technologists. A good many of us seized on the promise of digital to create a better world and the fight is far from over.

The Martin Grids

Martin Grid #4

Some further explorations in a code-based response to art. Last year I stumbled across the Agnes Martin retrospective at Tate Modern. I wasn’t aware of her work at all, but one of the joys of Tate membership is encountering surprising things that you wouldn’t normally seek out. I went back again and again, and subsequently read everything I could about her. I can’t really fully explain why her stark abstraction and pale colour palette has got so under my skin, but I haven’t stopped thinking about it since. I don’t mind saying that I got seriously emotional, particularly in the room that contained The Islands.

The mathematical precision of her grid paintings clearly lend themselves well to a programmatic response, and I wanted to explore this a bit in code. As luck would have it, I recently found that the peerless Joshua Davis (who has been a massive influence on my digital life since onceuponaforest.com) has made his Hype for Processing tutorials in generative art available through Gumroad.

I’ll save some specific thoughts about Hype (a framework that I used to use in Flash for music-reactive visuals) for another post as I explore it further, but for now, it’s reintroduced me to Processing as a language, which will, finally, now replace Flash for me as my creative technology tool of choice. There are some barriers to entry – mostly in the translation model which is exactly what Hype sorts out for you. For this task though, I wanted to try and stay away from helpers but have a pretty stark method of producing random grids. Nothing remotely complex about any of this stuff, it’s drawing API 101. What excites me, however, is the ability to reduce the process to it’s most fundamental quality. As I’ve read more and more about Agnes Martin’s life and practise, I’ve been hugely struck by her own quest for an ordered simplicity in describing her perception of the world and how it’s translated into her art. As someone who has had a difficult couple of years, this appeals hugely to me. In fact the very basis for my finding a minor creative renaissance in myself at the moment (musically mostly, but also in my appreciation of art) has been in a careful curation of my mental environment, removing harmful things and managing the remainder into some kind of order.

Agnes Martin grid paintings
Agnes Martin, Untitled

I’d like to extend this response to Martin’s grids into a more procedural practise, humanising the lines and introducing additional elements outside the mathematical constructs which are her artistic work at it’s most reductive. As she moved through her body of work, an emotional element enters into it, mostly through the use of a muted pastel palette. It’s this aspect that I found most appealing about her. We tend to think of ordering a busy, noisy mind (whether through therapies or drugs) as a removal of those hurtful, uncontrollable emotional elements. Where as I have found, both in my own experience, and how I perceive Martin’s work, that the abstraction of that noise into an ordered form – the grid, a schedule, a structure – gives space for an honest opening up of emotional responses. And perhaps a more authentic creativity as well.

Examples of Martin grid outputs:

Martin Grid #3

Martin Grid #3

Martin Grid #5

Martin Grid #5

Gallery – 10 outputs of the Martin Grids

Code (Processing):

int pad;
boolean frame = true;
int cols;
int rows;
int gridCanvasWidth;
int gridCanvasHeight;
int tStart;
int picNum;

void setup() {
size(600,600);
background(235, 235, 235);
smooth();
pad = 10;
tStart = millis();
gridCanvasWidth = width - (pad*2);
gridCanvasHeight = height - (pad*2);
drawGrid();

}

void draw() {

// draw the grid every 5 seconds
int timer = millis()-tStart;
if(timer>5000)
{
tStart = millis();
drawGrid();
}

}

// press S to save a png
void keyReleased(){
if(key == 's' || key == 'S')
{
saveFrame("MartinGrid_"+picNum+".png");
picNum++;
}
}
void drawGrid() {
// function for drawing the Martin Grid on the basis of a random selection of columns and rows
background(235,235,235);
noFill();
cols = (int)random(2,70);
rows = (int)random(2,50);
float spacerX = (float)gridCanvasWidth/cols;
float spacerY = (float)gridCanvasHeight/rows;
float tracker = pad;
stroke(150, 150, 150);
// columns
for (int i = 1; i < cols; ++i) { tracker = pad + (i*spacerX); line(tracker, pad, tracker, height - pad); } tracker = pad; //rows for (int i = 0; i < rows-1; ++i) { tracker += spacerY; line(pad, tracker, width-pad, tracker); } if(frame == true) { stroke(20, 20, 20); rect(pad, pad, gridCanvasWidth, gridCanvasHeight); } }

Code and a response to art

hep

I took some time the other day to go to the Tate Britain and catch the Hepworth display. I had mixed feelings about it tbh – it was rather short and the curation was a bit odd. I didn’t get a sense of time and influence from the layout of the work so it was hard to get the context of each piece. That said, there were some remarkable pieces in there and it’s worth a visit.

I got home and felt like writing some code and so built this response to what I’d seen. I’ve always been struck by Hepworth’s use of string and the similarity with the mathematical models which I used to be fascinated by at the Science Museum when I was a kid. There is, of course, a direct influence which the exhibition touches upon here and there. In this, we see the influence of science on the arts at this time, and a direct reference in her work to non-artistic methods of visualisation.

It’s a bit of a work in progress this, limited to straight lines rather than the arced forms which Hepworth so beautifully renders. Maths is hardly my strong point but I’d like to crack that next.

What did strike me, though, was how like an artist’s process the workflow of writing code can be. You’re building something through process, shaping function and form from the clay of the tooling (language and frameworks). Making aesthetic decisions, sure, but also following a craft to create your vision. I’ve touched on this before in my experience of playing music, but I think it must be even more so with sculpture.

I suspect that all programmers could learn a lot, not only from the practises of artists, but also from their routines and the development of their craft. When I was in Barcelona earlier this year, and spent a hugely emotional afternoon at the Miró museum, I immediately bonded with the idea of Miró’s trips out of Spain to Paris in particular, where he connected with other artists. This is also true of Hepworth, whose associations, particularly with Nicholson (obviously) and Mondrian can be traced through her early work. In that respect, coding communities do a great job in bringing movements in coding together.

One could argue that we’re in a golden age of community-driven quasi-artistic movement in code. In the spirit of innovation, I’d strongly recommend learning a little about how artistic movements have helped shaped the work of great artists, and drawing some inspiration from the organic developments in the history of art which resulted.

Streaming media and the organisation of my content

I can’t help but love Spotify. Even though they have probably contributed more to the death of the record buying public than Napster (and I have a vested interest in this), Spotify + my Sonos one = beautiful.

I love Netflix as well. Libraries of great content, seamless function across devices so I can move smoothly from the living room to the bed to my friend’s house.

But something is bothering me about digital media libraries, and it’s the same thing that bothered me, constantly, when I was working at Sky alongside their EPGs. I was hoping, but failed, to do anything about it there and I feel like it’s a massive unscratched itch for me, so I’m going to just say it for now.

Why are digital media services all so bad at organising their content?

I’m sitting here in Spotify right now, trying to create a mirror of my record collection. Simple enough task. It’s a data collection. A collection of objects bearing properties like:

 id:
 title:
 artist:
 spotify url:
 artwork url:

etc. I’m pretty sure that Spotify has all this metadata available. I know that Netflix has it. So why then do they not surface it within an interface to allow users to make their own decisions about filtering and organising the content that they are interested in?

I have sat in many planning and UX meetings where product owners have argued over the ‘perfect’ view of their content. But, when you consider that the final output of this is inherently dynamic – literally a collection of pixels within an interface – then this is absurd. If Spotify’s interface was in hardware I could understand it, but why can’t we have a more dynamic method of organising and filtering our libraries? If you consider the interface not as a perfect solution for a lowest common denominator audience but instead as a dynamic, realtime view of the data model, then you would be rewarded with far greater engagement with the service.

One big problem with content selection and discovery is that not only is my taste in media completely subjective, but so is the selection I’m likely to make at the point I’m making it. This is governed entirely by what I’m in the mood for right now and this is where the static interface lets me down.

In Netflix’s case this means that I have to scroll through reams of useless suggestions, based on something I recently watched in a completely different context to what I want now. Much has been written about Netflix’s powerful metadata engines, why can’t some of this power be placed into the hands of the users to filter their library to show me custom suggestions which I control (because despite the internet thinking it knows everything about me and my tastes, it doesn’t have a scooby about what I’m looking for right at this moment). We have been obsessed for years now about finding the perfect algorithm and the perfect UX, but we are missing the benefits of handing the reins over to the user to make the decisions that only they know best how to make.

But I’ve always thought of any collection of related objects precisely as a ‘data collection’. I would be shocked if this is, indeed, not how it’s handled programatically in the software. Give your users the power which your software enjoys.

In Spotify’s case, my only option is to search (and how often do I really know what I’m looking for until I get inspired by something?), or to rely on my playlists, which I can only ever have one view of, a nested tree. Further filtering is available in the main window view, but only on a track by track basis. My record collection alone is probably a couple of thousand albums, and that’s before I even get into all the stuff that I don’t own but sometimes want to listen to, guiltily (and this is where Spotify and Netflix shine – just don’t assume that means I want to listen to/watch it all the time, the biggest flaw of any recommendations engine which has no context to my decision at that time).

Give me the following please guys:

+ The ability to browse my collection visually, listed by artist, genre, microgenre, record label, year or any other piece of metadata you hold. Album covers are vital – there is always much higher recognition of a visual image than parsing thousands of lines of text. Let me sort it. Give me subtractive filtering tools so that I can gradually narrow down to my choice

+ The ability to scan a barcode on my CD or Vinyl and match it to the Spotify collection (or at the very least search by UPC)

+ A decent query engine instead of keyword search. So if I’m in the mood for East coast political hiphop or secular renaissance madrigals you can surface me some content. In Netflix case, they actually do this anyway to power their suggestions, so why can’t I make my own queries against their formidable metadata? (and whilst I’m here, why can I not permanently see recent additions – sometimes it’s there, sometimes not…agh!)

+ The ability to batch organise, add, delete my playlists and collections. Tidying up my library the other day was RSI-inducing.

+ Multiple views of my playlists in a proper interface of it’s own, not just in the sidebar. Make it off-canvas if you need to. Hell, even a separate companion app. Function follows form when it comes to interfaces and if your form is crippled, so will the functionality be.

+ The ability to import/export my collection. Even better, open up the organisation, favouriting and playlisting of content to an external API so that other developers can do it better if you can’t.

Streaming services have metadata right at the heart of their product and, by insisting on a restrictive interface for users to only surface and organise their huge content repository the Netflix/Spotify/iTunes/Play Music way, they are, for me at least, hugely restricting the service’s usefulness.

And if there’s one thing we’ve learnt in the digital age, it’s only a matter of time until someone comes along and does it better.

On Rachmaninoff and failing fast

“Failing fast” is an oft discussed principle for innovation, levied particularly at large, risk averse companies that are struggling to innovate in the digital realm.

It stands to reason that you don’t fail at what you already know how to do. It also follows that if you’re only doing what you already know how to do (or following ‘standard practice’) then it is unlikely that you’ll innovate. We learn, and innovate, by stepping outside of our comfort zone and going into uncharted territory. It’s not so much a case of ‘failing’ but having the courage to tackle the unfamiliar or the difficult, being prepared to make mistakes, and working through them until you know how to do it.

I am a *very* lapsed pianist. After going through the grade system, during a childhood of constant study of music, I didn’t really play the piano properly for years. As I have returned to the instrument in adulthood, I’ve found that my ‘chops’ are not what they once were, and I stumble around pieces that I would have been able to play fluidly. I’m a tinkerer most of the time, playing the simple stuff, improvising, allowing myself to make mistakes without correcting them and I tended for a long time to ignore harder passages or unfamiliar pieces because my technique wouldn’t allow it.

Lately though, circumstance has given me a new goal in my musical life which I think acts as a neat analogy for the importance of failure in business. The Rachmaninoff C#m prelude is an awe-inspiring and fear inducing piece of music. It’s in a difficult key, with sections where your hands have to counter-intuitively cross over one another. In the latter section, the score moves onto two staves – sight reading this alone is a head scratcher for an amateur pianist – so many notes, so many accidentals. Better stay safe and rattle through some comfortable Beethoven instead.

Rach Cm Score

And yet, as I make a concerted effort to play it, the piece’s logic starts to unfold for me. Even the last section that is so daunting on the page follows an actually deceptively simple logic – block chords, moving in parallel. Find the right shape with one hand and the other will follow. It requires accuracy and concentration for sure, but if I slow down, repeat parts which I’m stumbling over, become comfortable in the key so that my hands naturally find the shapes they need to be and bring out each phrase fluidly, the more the piece comes together.

And tonight, I actually got through the whole piece, a piece I’ve wanted to be able to play all my life, from beginning to end. It was messy and played with many mistakes, but the notes don’t seem so daunting to me anymore, and I don’t stop at the splitting of the stave as I so often have in the past. In fact one of the reasons why I often stopped at this point was that I love this piece, and it pained me when my execution of it didn’t sound like I know it should.

This pushing through the pain point has also had an interesting side effect – after an hour or so of playing the Rachmaninov, when I subsequently play an easier, familiar piece, say Debussy’s La Fille aux Cheveux du Lin, I play it fluidly, almost effortlessly, my fingers moving across each phrase with such ease that all my attention can be placed on the expression of my performance, and it opens up new capabilities within my technique that makes other difficult pieces far less of an ordeal to play.

As we come to tackle unknown territory in technology, in business, even in our everyday lives, we will *not* learn, grow, innovate or refine our skills, knowledge and capability if we stick to the strategies that we already know. We have to embrace unknown territory, not be disheartened if we fail, break the problem down and work through each section until it untangles before us.

The fear of failure in a large business is analogous to hearing a piece of music played badly. If the work you are producing does not ‘sound right’ – if it doesn’t match to what we think our business output should look like, or what our market expects, then we often deem it a failure and don’t progress further, and this is what kills any innovation.

But if we stick through it, working through each difficult passage and learn from our mistakes, then not only will we achieve things we never knew that we could, but it will also make what we already know how to do easier.