Show me what solidarity looks like

If tech workers were to organize in real numbers, what might they fight for?

Gawker is a digital media company built on grabbing people’s attention, but workers there have just now managed to find a brand-new way to do so: by voting to form a union. Here’s Hamilton Nolan explaining why:

Though our company is relatively well run, pays relatively competitive salaries, and treats its employees relatively well, there are still certain issues… We would like to ensure everyone receives a salary that is fair for their time at the company and the work they do. We would like to ensure that things like pay and raises are set in a fair, transparent, and unbiased way. We would like to have some basic mechanism for giving employees a voice in the decisions that affect all of us here.

More people were watching this vote than the number of employees involved might normally warrant just because of where it’s happening. A union is a novelty for an Internet company, and a union victory at Gawker is hard to explain away as the product of super-exploited blue collar labor or some kind of sclerotic old-economy culture. But it’s also interesting because of the particular issues Nolan raises, which connect with the recent #talkpay conversation about pay and inequality in tech. To me, as a software developer, Nolan’s argument hits closer to home than a lot of rhetoric around unions, even though Gawker isn’t quite a tech company.

Pay, transparency, and class

Software developers—who are by no means the only kind of tech worker, but more on that below—aren’t, as a whole, hurting for money. Last year, according to the Bureau of Labor Statistics, software developers and programmers in the U.S. earned a median of $91,320, while the average worker took home a meager $35,540. Nevertheless, questions about transparency and fairness seem to have a wide resonance even among those of us who are treated, in Nolan’s words, “relatively well.”

Why? Well, for one thing, discrepancies in pay and raises aren’t just individual. Women are paid less, very often—in fact, this was Lauren Voswinkel’s impetus for initiating #talkpay. People of color are paid less.

Fortunately, sharing your salary information with your coworkers is one of those convenient forms of solidarity that is simultaneously immediate self-interest, even for the white men who make up a disproportionate number of software developers. More information can only give workers more leverage.

Employers already know the going market rate for most types of employee, including software developers, and they certainly know what they’re paying their current employees. If workers don’t have the same information, they might underestimate or overestimate what they could achieve just through negotiation. If you overestimate, your boss can just say no. If you underestimate, your boss will happily keep the money for the company. On the other hand, if you know what your coworkers make, you can refuse to settle for less.

In other words, transparency is a class issue, benefitting workers at the expense of bosses. Software developers don’t usually like to think of ourselves as workers with distinct class interests that conflict with those of our employers, but at a certain point it becomes hard to avoid.

To see how hard to avoid, let’s turn to Patrick McKenzie, CEO of Starfighter, a startup trying to help companies hire programmers. In an interesting piece, McKenzie writes that while #talkpay “is rather Marxist in character… this capitalist encourages you to look beyond that.” But he doesn’t manage to look very far beyond. He has to admit that, as a capitalist, his openness about salary depends on the fact that “these days I’m a) CEO of a company I co-own, b) have no investors to keep happy, and c) have no reasonable prospect of ever having a [consulting] client again.” (And he might have added: it’s good marketing for the job-seekers his startup needs to attract.) On the other hand, he writes, “everyone who works for a salary” shares “general interests” in “understand[ing] what the market is like”—that is, in pay transparency.

When the capitalists are explaining how workers and employers have opposing interests, what’s left for the “Marxists” to do? Perhaps, to prompt us to consider what we might do about it.

Organizing as workers

Let’s imagine, for a moment, what it might look like if programmers were to organize as workers—in unions or otherwise—and demand a collective voice in decisions that affect us.

We might talk about hours, and taking work home, and ask for reasonable schedules, and accommodations that work for people with families. We might want rights to contribute to open source projects or veto the release of insecure, privacy-violating, or otherwise unprofessional code. And of course we would probably talk about pay.

What’s new, though? After all, we negotiate pay and to a certain extent working conditions now. And at least as long as this boom or bubble lasts, many of us have a significant amount of market leverage.

But when people get together, it’s not just the leverage but also the focus that tends to change. It’s easy for companies right now to design pay and benefits packages pitched at attracting “brogrammers” with no dependents, and keeping people in the office as long as possible with dual-purpose perks like free food. When workers organize, however, each person has the opportunity to get the support of others for far-reaching demands that only directly benefit a minority—with the expectation of reciprocity. This is a constitutive part of building solidarity, in a way that doesn’t have an analogy in a market. It’s hard for an individual (non-CEO) to negotiate for company childcare, but workers collectively can. The same goes for fair hiring, pay, raises and promotions regardless of gender, sexuality or race. Or an end to two-tier employment systems involving precarity for contractors or immigrants on an H1B—or for “non-technical” workers.

The tech industry is filled with people whose labor, though essential, is devalued by the market: people who clean, plan events, handle logistics, interface with individual users or design digital user interfaces. (Or, sometimes at smaller companies, do all of the above.) It’s not inevitable that these positions tend to pay poorly. But whether the leverage of those who do this work correlates with the necessity of their labor, or with the number of substitutes available on the market, depends on whether they are negotiating collectively or as individuals.

From here to there

It might very well be the case that software developers won’t organize in large numbers or with other workers until the industry changes dramatically (as they tend to do, eventually). It’s certainly not easy to plot out a path from unionized janitors and bus drivers, small voluntary organizations with ugly websites, and unexpected breakthroughs at loosely-analogous places like Gawker Media, to mass programmer organization. But if you’re not satisfied with the way things are—if you’re not ok with pay inequality, with life-consuming hours, with widespread sexual harassment, with arbitrary management authority—then there is something you can do about it. And it can start as simply as talking to your coworkers about what you get paid.


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 )

Google+ photo

You are commenting using your Google+ 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 )


Connecting to %s