””””’,,,……………………………..e..pppppppppppppppppppppppppppyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyffffffffffffffffffffffffffffmfffffff//ggggggggggggggggggggcccccccccccccccrrrrrrrrrrrllllllllllllllllllllllllllllllllllllllllllllllllaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddoooooooooooooooooooooooooooeeeeeeeeeeeeeeeeeeuuuuuuuuuuuuuuuuuuiiiiiiissdddddddddddidddhhhhhhhhhhhhhhhhhhtttttttttttttttttttttttttttttttt/nnnnnnnnnnnnnnnnnnnnnnnnnnnsssssssssssssssssssssssss;;;;;;;;;;;;;;;;qqqqqqqqqqqqqqqqqqqqqqqqqqq xxxxxxxxxxxxxxx xxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxx x xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvZzzzzzzzzzzzzzzzzzz////////////////////////////////////////////////////////////////////================================================“““““““““““““`[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\——-\—————–nnnnnn
One of my favourite teachers ever was my 11th grade history teacher, Ms. Conway. She would give lectures that made us laugh and cry. But the most memorable thing she ever said to our class follows:
How many of you are feminists? (a few people raise their hands) You know, feminism only means that you think women and men should have the same rights. Now, how many of you are feminists? (nearly everyone raises their hands)
(see the definition of feminism at Merriam-Webster, e.g.)
Since then, I’ve firmly identified as a feminist. Maybe that makes me a member of a minority, especially considering the sort of person I seem to interact with on a daily basis. My feeling is that feminism is viewed as an extreme, radical thing, and that feminists are seen as people who hate men. Neither are true – feminism is the simple belief that neither women nor men are better than the other.
With that in mind, let’s talk about GNOME’s “Outreach Program for Women” (OPW), for which I was a mentor from January through April, and through which I met a lot of cool and interesting people. Another Wikimedian, an OPW intern herself, has already written about the idea that OPW is a sexist program, and I have to say, I have had a very similar feeling about it from the start.
In December, when I was asked whether I’d like to be part of more mentorship programs, I responded “yes” emphatically. A few days later, I got some emails and IRC messages about OPW, and read the literature. I was excited that the program would be bringing in more contributors for Wikimedia, so I again responded yes.
After a few more days had passed, though, I thought back on some of the literature, and on some of the things I’ve read in the past about affirmative action programs. I asked a few questions in various channels about why this program, specifically, needed to exclude men. Why was it that a program offering paid internships for working on free software was being offered to half of the population but not the other? The answers were a little dismissive, but satisfactory for me at the time, and ones that I had heard before and would hear again: Women are disproportionately affected by the current lack of women in the tech industry, we need to actively seek them out, and it’s helpful for them to have a place where they feel comfortable when they start out working somewhere, as well as a place that specifically indicates to them that they’re qualified to apply.
During the program, there was a lot of busy time. Not a lot of progression of my ideas on the matter. When the program closed, though, I asked in the OPW channel about the same thing. The same answers seemed to come out, but for the most part, I’m not sure I was convinced. While I’m glad that women feel more comfortable in that scenario, it’s at best a stopgap measure. Sustainable growth isn’t accomplished by treating women specially, it’s accomplished by making sure that the industry, and the communities where women will be joining along with men, are friendly enough places that nobody feels excluded.
Segregation isn’t the way to solve segregation. Affirmative action was maybe a good idea once upon a time, to open the door, or maybe just because we didn’t fully understand the issues at play, but we’re in a different time. Discrimination, at least in the Western world, is not looked upon as acceptable, and sexism is no exception. So maybe we should stop practicing it as if we still need to use these temporary solutions to crack open the door. The door is already open, or opening, and we just need to let everyone through. Having women-only events or programs excludes men who might want to learn too.
Things People Say
When I ask people why they’re choosing a women-only event, group, or program, I often hear many of the same answers and continue to be unimpressed. A few of the ones I’ve heard are below (please, comment, and I’ll try to add yours!) (also, if you want to rebut one or more of these, I’m happy to continue the conversation in the comments)
- Women need to be able to count on support from peers
- This is one of the more common explanations I hear, though it comes in different forms. Women and men sometimes have different needs, but some men have the same needs as most women and some women don’t have the same needs as other women. It’s ridiculous to offer a service to women and not men just because most women need the same service.
- Women are intimidated by the male-dominated industry and need a women-only place to find support
- While there’s certainly some truth in the intimidation, I reject the concept that women can only find support with other women. If there’s some *quality* of women that you’re looking for, maybe you should start a group that allows entry based on that quality rather than based on the professed gender of a person. It’s insane to block men from entry simply because they’re men.
I fully recognize that I’m missing things here. I invite people who understand this topic better than I to comment and help me understand. Hopefully we can learn from each other. I promise not to dismiss your ideas out of hand and strive for a fair conversation on the subject. I want to learn from you just as much as you want to learn from me.
From the W3C CEO’s Q&A pages:
A situation where premium content is relegated to applications inaccessible to the Open Web or completely locked down devices would be far worse for all.
When I first visited the page, commenting was disabled, so I wrote one anyway. Its text is below.
But of course you realize that’s what you’re doing.
If you build DRM into an HTML spec, and some free browsers decide they want to implement it differently, or not at all, then those browsers won’t be able to access the premium content.
And how do you intend to decide whether a browser implements these interfaces correctly without unnecessarily impeding free development and experimentation in the browser world? Are you going to have Microsoft sign our browsers’ binaries? Is the W3C going to issue keys after reviewing each browser version? I run Firefox Nightly, how am I going to access premium content?
This is a step away from your precious “Open Web” and it’s obvious. Let the backend and delivery systems deal with security, the browser shouldn’t be the police force against the user. If someone really wants to shackle their viewers, let them do it through their own applications like they always have. HTML is *our* media format and it would be unfair of the WHATWG or the W3C to suddenly give it to the media industry.
Oh hi, world!
In classic Mark fashion, I’ve changed my blog platform again. I was using a static site generator, but I figured I’d give WordPress another shot. It looks like it’s doing OK so far, so I guess I’ll stick with it!
My profound sadness that I can no longer blog from vim, but hopefully this will work just as well. And maybe encourage me to be a little more prolific.
Anyway, I’ll be moving over the old posts to this blog. Hopefully I manage to move all of them over correctly!
In their efforts to vet job applicants, some companies and government agencies have started asking for passwords to log in to a prospective employee’s accounts on social media sites, such as Facebook and Twitter. Civil liberties groups, social media users and others have criticized the practice as a serious invasion of privacy, likening it to handing over the keys to your house. (source)
As I read this, I couldn’t help but thinking, “Your house? Really?”
In my mind, it’s really more like copying a key that opens the doors of a stranger’s house, going inside and leaving a bunch of personally identifiable and sensitive information, and then leaving copies of that key in really stupid places. I can appreciate that the above analogy is designed to illustrate the security risks in giving out your passwords (which, I suppose, could possibly still be news to someone, if they were an IDIOT), but the insecurity is much more fundamental than that—if you use Facebook’s warehouse to store information, any information you store is essentially theirs. Talk about privacy and confidentiality policies all you’d like, but the way they process and store it is totally up to them, and you have no way of knowing what they choose to do.
Total topic change
I’m sure I won’t convince anyone, since the people reading this are either free software advocates who have heard this and either accepted or dismissed it for one reason or another, or they’re people who read because they know me and for whatever reason can rationalize their use of Facebook and the like.
Maybe that means I shouldn’t write this stuff anymore? Maybe it means it’s late and I’m tired? I’ll read this again tomorrow and see if it makes any sense. Mark out.
Almost a year ago, I wrote about a combination of freedom and order that had been necessary in the early days of the United States, and that may still be necessary here and now, in the context of the Free Software movement. Without going too deeply, I basically extolled the idea that people should focus on higher concepts, rather than the nitty-gritty details like prices, economics, and so on. My theory was that people would be more likely to be interested in the higher concepts.
This article is not a re-examination of the concepts set forth there, though that may be necessary. This is a more philosophical approach to analyzing a phrase I’ve been considering for months.
Great worlds come into existence due to great order.
Great works come into existence due to great freedom.
Though diametrically opposed, both are necessary for a thriving society.
This statement, to me, sums up why the above-linked post is vital to the success of the Free Software movement. Basically, without order to the madness, there will not be a movement for very much longer. We’ve far surpassed our years in chaos, and we need an organizing document, perhaps one written by someone not in the FSF, that might help us to push in the same direction, rather than fighting each other and being unproductive.
I know! It’s different! I usually write about total and absolute freedom, but this is a very different tone, and I’m sure I haven’t been clear about what I think is necessary.
The previous “Freedom and Order” post used the Constitution, and the American Revolution, as an example of a successful document establishing order. Well, they needed to provide order for a nation, a set of people, and so they defined ways for those people to give input on their laws.
Perhaps what I’m saying is, we could use a democratically-elected board of people, perhaps with some small amount of pay, who could help create things like codes of conduct, funding for new free projects, and ways for the Free Software movement to be economically viable. The money flowing in and out would likely be nothing compared to the U.S. Congress, but there might be enough to provide for a few “law” makers and a few people to help bring those “laws” to fruition.
OK, I’ve derailed my intent a bit. Let’s get back on track.
The Free Software movement has no real, focused purpose as of right now. A lot of people advocate, and a lot of people make new software, and some people do testing, documentation, translation, et cetera. But, very few people are following any particular goal. They simply make what they need to make in order to do their jobs, or accomplish their own selfish goals. If they want to help the community, they make a project that helps the community, or they triage bugs, or they help people in IRC. If they feel like spreading the word, they advocate. But there’s no central, absolute purpose for the entire movement, and that means a rather unfocused effort from everyone.
For fear of rambling, I’m going to stop now, but I hope I made sufficient sense. Go freely.
In each of these projects, there exists at least one way to add on small, additional features, or change the way the software behaves. It has struck me as a very interesting construct, and I think that it could be a very useful thing for almost any project to have. So, I’d like to share what I’ve learned.
My experience with MediaWiki extensions is mostly through the two I’ve helped so far: EtherEditor and UploadWizard. They both do a lot of different things, and they both tie into the MediaWiki interface in one way or another, but the really interesting part of the development of an extension is that, while there may be a lot of interplay between the extension and MediaWiki proper, the extension very much feels like its own project. You can easily install and remove the extensions, and they sometimes have their own code hosting. Having this separation is immensely helpful for the developers, because it gives a sense of independence, and allows for much more modular code.
Of course, it’s also a gateway to modifying the core of the project. While I did fix most of the bugs I found in UploadWizard by simply changing the UploadWizard code base, there were a few instances where I was forced to enter the MediaWiki code, and fix something there. Maybe that seems undesirable, but having worked with the extension for a few weeks by then, I was relatively well-versed in the MediaWiki style, and could dive in with relative ease to find the problem. This leads to another benefit of this kind of contribution: It makes for very literate contributors, and since everyone has to play in the same sandbox, they very often contribute any patches to core back to the main project.
I’ve talked about Minetest before, but this time is a bit different: The modding API has existed for many months now, and in the words of Perttu Ahola, the main developer, game content has exploded.
The really interesting thing about the Minetest system is, while the core game is written in C++, the mods are all written in Lua. This was a choice made early on, and it somewhat separates the two communities—modders and “core” developers. While I’m not sure there’s any way to circumvent that separation, I feel it could be handled better, and perhaps I can muse on that in a later post.
In any case, the Minetest system also offers a very interesting benefit: People have dived in to create something, and hopefully learn something, who otherwise might not have learned to program at all. This is a parallel to the World of Warcraft modding community, and even uses the same language. People who happen to learn the game, and enjoy it, eventually learn something of the Lua API and start playing with it. After talking to the rest of the community and learning from them, they learn even more about programming.
Another confusing part of the Minetest modding community is that, while mods are simple to install, there is no real central place for them as yet. I’ve done my best to create a starting point, software-wise, but it has mostly been stagnant, and nobody appears to be interested in using it. The forums for Minetest house the majority of the release announcements and documentation, but the community could definitely use a move to a more comprehensive place for issue tracking, wikis, and code hosting.
The final example is one near and dear to my heart. Etherpad Lite, a fork of Etherpad, has been recently building a more robust community, filled with new faces. A lot of documentation was provided, and suddenly the Plugin API was useful, and people started writing code for it.
The most interesting change here is that, while a lot of people have enjoyed using the Plugin API, there are still a lot of missing features. Almost every plugin that gets discussed in the IRC channel (#etherpad-lite-dev on Freenode, come join!) will require some form of modification to the core. But the really cool thing is, the contributors are able to just do it! Now, with MediaWiki, it’s definitely possible to contribute a patch to core. But the response time is usually pretty high, which is fine, but it makes for some very slow integration time. If a company wanted to deploy an extension, but needed a new hook to do it, they might need to wait weeks, unless they made a lot of noise, to see that new hook integrated into the core. There’s a danger, there, of losing potentially helpful contributors. To the credit of the Etherpad Lite devs, they have responded with a latency of, at most, a day or two. And they’re getting more numerous, and faster.
Conclusions, take-aways, do this with your project
I wanted to compile the really useful, bare-bones, what-you-must-absolutely-know points of this post, so that anyone interested in adding this sort of system to their project, or anyone interested in improving their existing system, can use them. Here they are:
- Allow as much freedom as possible to your contributors. I’ve seen projects that require a specific API be used, that require registration and/or payment for the SDK….none of that, please. If you’re going to let people build on top of your project, give them an open field to build on, not some gated community.
- Choose a simple language. Now, if you’re paying attention, #1 should mean that you allow any language, but assuming that’s not possible, please don’t choose a compiled language. Use something interpreted, and make it at least somewhat relevant to your project. For MediaWiki, PHP was an obvious choice, but Minetest’s choice to use Lua also made some sense.
- Make it sort-of-centralized. However much I disagree with GitHub, I have to begrudgingly say that they have a nice system for this sort of thing. I use Gitorious to host my mods and plugins, but they don’t offer issue tracking, so if you do go that way, be prepared to set up Bugzilla or something. Don’t, for example, host your mods on a forum. It’s not easy enough to access, and the information is too sluggish to access.
- Document it really well. Minetest does a pretty great job of this, since there is a big file with *all* of the API methods and tables, as well as the “default” mod which has pretty good examples for just about anything you might want to do. MediaWiki tries, I think, but they could use something a little more concrete.
- Make good examples. This is a sub-part of #4, but it also deserves its own separate item. With Etherpad Lite, we made a separate repository with the skeleton all built out. Neither of my other examples, to my knowledge, have such a thing–or at least, it’s not easy to find!
Please take these five simple points to heart, and do consider using this idea of allowing small additions to a project via simple, separate modules. It’s a really great way to build a huge community of awesome developers.
In my free time, I sometimes practice something called Parkour. In fact, my username (MarkTraceur) comes from that art, because “traceur” is a term for a person who practices Parkour. This art is a very intense physical discipline, combining simple, natural movements with martial arts techniques to form a set of “best practices” when it comes to moving through obstacles. In reality, it’s just a set of tools that help you evaluate problems of efficient movement.
Well, since the rest of my life is dominated by software, the natural thing to do is to compare Parkour to programming, and see if I can’t learn, and teach, something interesting. First, I should probably explain how I see Parkour.
Parkour, as explained above, is an art of movement. It helps you train a set of movements to the point where you’re very comfortable with all of them, and can easily reach for and execute the best movements for any particular situation. These movements include such things as vaults (for getting over things), wall-climbing techniques (for getting up things), underbar techniques (for getting through things), jumping and landing techniques (for getting off of things), and other more general movements.
Parkour isn’t just about exercise and practice, though. The community and organized practice of it was mostly started with the mantra “be useful”, and there is a lot of philosophy that goes with it. There’s also a huge slew of mental preparation a person needs to do in order to do some of the movements, and even judging the best movements for a situation takes a lot of thinking.
The really interesting thing about Parkour, to me, is that there never seems to be a single “best” way to do things. While most people would look at a situation and agree that one movement or another seems good, another person might come in and have a different idea that works better for them. For example, while going over a rail with a speed vault might be good for me, a shorter traceur might be better served by going under it with an underbar. Many of these questions share a similar non-deterministic quality that really appeals to me.
While my blog is mostly frequented by technical people, I expect this article in particular might draw some traceurs who don’t fully understand programming! So, I’ll try to explain what’s necessary for this article.
Programming is the act of telling a computer, through a list of commands, how to behave and what to do. For example, as you’re reading this on your web browser, your computer is likely listening on a network interface (wifi, 3G, 4G, or ethernet) for connections. It doesn’t do that because it innately understands, but because a programmer somewhere wrote the necessary words that told the computer “wait here, and listen for this data, then perform this action”.
The really cool parts about programming and the really cool parts about Parkour, I think, seem to cross pretty regularly. In programming, I often come across a situation where the solution I create might not be the one someone else would use. Most of the time, these solutions differ in their speed, or in the amount of memory they use, but depending on what you’re trying to accomplish, either one might be “best”. Admittedly, there are certain things (like “crash the computer, delete all the files”) that would almost always be excluded from being the “best”, but there are so many different qualities of each solution that most of them will be good in one way or another.
But the fun doesn’t stop there! Most traceurs will continually train their skills over and over again. Well, programmers do that, too: The more we write in any language, the more fluent we get with it. The first time you use a language, you jump straight into it and try really hard to use it anywhere you can. Once you learn the language well, you keep building on that knowledge with additional libraries, additional and more difficult file structures, and so on. Traceurs will be familiar with this concept, called “progression”.
Even some of the simple philosophical ideas bridge the gap. Where traceurs say to “be useful”, most programmers will also recognize a similar concept. Where software is free, it’s common courtesy (or sometimes legal obligation) to release derivative works as free. Where you download a file, it’s common courtesy to mirror it if you can. Where you fix a bug in a free library, it’s best to contribute that fix back to the original author. This is also similar to the general traceur practice of leaving a training spot better than how you found it.
The biggest difference between these two art forms is the physical involvement inherent in Parkour. This makes it an extremely difficult thing for a beginner to do with any sustained effort–the physical demands of hauling oneself up and over walls repeatedly is not to be taken lightly! For those of us who love sitting in front of flashing pixels for hours (or days) at a time, it’s very difficult to start.
Another huge difference is that, in software, there are a lot more concrete solutions for specific situations. In some places, there are well-known mathematical proofs that show the superiority of one solution or another. This is a result of two other differences: One, programming has been around, and popular, for a lot longer than Parkour. Two, programming is much more concretely defined, due to its mostly-deterministic nature. Above, I described the non-determinism as being a similarity, but programming was a lot closer to being deterministic than Parkour.
- Parkour is fun! If you haven’t tried it, and you’re in the Bay Area, feel free to contact me and drag me out on a run.
- Being useful, and generally being helpful to your community, is a great philosophy to have. It makes for a really cool community, and it makes you feel good!
- Thinking about a problem as having more than one “good” solution is more productive than thinking about it as having only one “best” solution. Maybe you’ll eventually decide that, in this situation, there is a best solution, but not necessarily acknowledging it will help you to generalize the other solutions for the next time!
- Programming is fun! Maybe it doesn’t seem like it, but there are a lot of similarities between these two disciplines. If you love the mental high you get from computing paths through a course, you’d also love the mental gymnastics involved in getting a computer to do what you want!
- Other communities have similar philiosophies to “be useful” and “leave the spot better than how you found it”, so keep doing those things! In particular, contributing to the community is a really great thing to do, and traceurs (and groups of traceurs) should make that effort a priority. Even just welcoming the community into your training sessions is a great benefit.
- If you don’t already consciously consider that multiple solutions might be desirable in a particular situation, try! Next time you go out, do your normal training exercises, but then turn around and look at the obstacles a second time. Consider what you might do if you were shorter. How would you get through if you had a broken arm? What about if you couldn’t touch one of the obstacles for some reason?
Thanks, as always, for reading, and go freely!
Last week, I wrote a blog post about people who seem to be generally hostile towards free software advocates. A lot of people weighed in, and I’m happy to say that it’s resulted in a significant shift in my thinking.
The first thing I needed to do was to split up the question into several parts; so I split it into different groups of interaction. Those groups, and my conclusions about them, are as follows:
Free software user towards other free software users
This category, I think, was the one I was most worried about when I wrote the original post. It’s clear to me now that, in order for someone to make most of the criticisms that I highlighted in the previous post, someone would have to be aware of at least parts of the GNU philosophy.
These people are usually irritated with a free software advocate who disagrees with their preferred licensing scheme. Copyleft advocates don’t get along with permissive advocates, and vice versa. I’ve mostly observed permissive license advocates being discourteous, but I’m sure copyleft advocates have been just as discourteous at some point.
This category of hostile interaction is absolutely ridiculous. Sure, there are disagreements, but it’s foolish to argue about such things. Even the most hardcore copyleft advocates agree that, in an ideal world, permissive licenses would be better. Copyleft advocates use the tools available to them to ensure the freedoms they desire, for themselves and their users. And permissive advocates, while they’re usually very friendly and practical people, get very offended by copyleft advocates who are too insistent, claiming that copyleft is too restrictive. Both groups have goals, but both are working towards digital freedom. That ultimate goal needs to be the focus, rather than the particular tools used.
Free software users towards non-free software users who make free software
This is something of which I’m guilty, I’m ashamed to say. People who make free software for non-free platforms, like the iPhone or Windows, are sometimes victims of criticism because they straddle a fence between two worlds. But that fence is a huge barrier to some people, and the people who sit on it can help bring people across.
The problem, I think, is that when I try to help these people find free tools (like Gitorious, for example), I tend to come across as being too focused on one side of the fence. The people in this difficult position see me as attacking them, or their decision to help people in this way. I could try to explain at length that I mean only to find better tools for them, but that seems like wasted effort. They appear to be doing good work, so why bother criticizing? Someone making free software with non-free tools should be encouraged to continue making free software above all else. It might be helpful to encourage free developers to use Gitorious from the start, but criticizing their use of GitHub now seems unnecessary.
Free software users towards non-free software users
This is probably the most ridiculous form of hostility surrounding the free software movement, and probably the source of a lot of negative feelings. Free software users and advocates might occasionally look intimidating based on the fact that their information is something most people don’t ever consider, and don’t already understand. This fact combined with the very serious nature of most free software advocates makes for a very difficult person to converse with.
The best way to deal with this situation, then, is never to criticize, and never to obstruct people. I maintain, as I have in the past, that it would be better to not help people to support non-free software. However, rather than simply refusing without explanation, or with only a few words. Explain a way to accomplish the same thing with free software, and why you prefer free software. The goal here is to be verbose, so brush up on your ability to explain things to non-technical users!
Free software users towards non-free software developers
This is a relatively justifiable form of hostility, since the objects of it are directly opposed to the mission of free software advocates. However, there’s a problem: Developers are the best way to spread free software (more on this later), and we’re starting to alienate them!
Maybe we can’t win these people over with words, but it would be helpful to stop alienating them, certainly. For now at least, my best advice is to simply not advocate to them. Telling somebody that they’re doing things wrong is probably not the best way to win them over, and that’s really our only tack with non-free developers. Simply allowing these people to be, and encouraging them if and when they create free software, is our single best play.
In general, there are some things we should keep in mind when talking to the public. First of all, try to avoid “smear campaigns”. This is one of the most common criticisms of the Free Software Foundation in particular, and it makes a lot of sense. While Free Software is a reasonable idea, some of the ways it gets spread can be a little unnecessary and hostile. Simply calling technologies by their proper names will not cheapen the message at all, especially when the person speaking is already criticizing the technology for valid reasons.
Second, focus on positive reinforcement, rather than negative feedback only when things go wrong. I touched on this somewhat in the previous sections, but here it is again: We should be seen as an encouraging community, rather than some resistance that fights against people. This is why sites like OpenHatch have such great importance to the free software movement–we should encourage people to do good work, rather than criticize them for doing bad work.
Third, consider now that other freedoms, freedoms that aren’t related to software, are also important. While most of the time, people who make this argument simply mean freedom of choice. I maintain that freedom of choice isn’t freedom at all, merely an illusion–similar to allowing prisoners yard time. If you allow some amount of space, that’s good, but it’s still prison. It’s the same with non-free software: You can choose a lot of different software just like you could walk around the yard, but you can’t modify or share it, among other things.
Supply and Demand
One of the interesting points I’ve heard recently is that there are two major theories about the most effective approach. Some people prefer supply-side advocacy. This method is when developers are targeted, and they change their ways. This method costs relatively little, because there are fewer people who are more aware of the subject, but it can also be severely tedious. As we’ve seen, non-free developers are very set in their ways.
The other theory is demand-side advocacy, which is focused on users rather than developers. This takes a lot of time as well, since users can also be set in their ways, but are also troublesome because of their lesser domain knowledge.
My view of this is that supply-side advocacy should be the focus. Developers, while stubborn, feel good simply by making software. Add in altruism as a motivator, and possibly the ethical benefits of allowing their users freedom, and they’ll certainly be interested in making free software….or at least, that’s the goal!
Demand-side advocacy can be helpful, but since a lot of people don’t understand software, it can be difficult for them to understand the importance. If the landscape of free software gets wider, users should start to spill over more readily.
Thanks again for reading this blog, and thanks especially to everyone who contacted me in response to the last post. As always, go freely!
The free software community has been around for quite some time now–longer than I remember, since I’ve only joined in the past few years. And for some reason, though that time seems to have been spent on good works that benefit humanity, and advocacy that teaches people how to be free, the movement is sometimes the object of some hostility.
With every blog post, I encourage people to comment by emailing me, but for this post in particular, I’d like to make a special request for feedback, because this particular problem is a very important one to solve. If you have any ideas about how to further explain the below points, please email me.
One complaint I’ve seen very often is that free software advocates are mostly zealots. However, whenever I come up against that complaint, I turn to the dictionary definition of “zealot” and find the following:
- One who is zealous, especially excessively so.
- A fanatically committed person.
Both of these possible definitions involve some version of “excessive”, but that has never made sense to me. The second definition also includes some sense of irrationality, which also makes very little sense. Free software advocates love freedom, it’s true, and would rather have freedom than convenience. But that exact choice, and the preference free software advocates tend to have, are exactly the subjects of many romantic depictions of heroic figures, both in history and in fiction. New Jersey still immortalizes it on their license plates, and countless authors continue to speak highly of those who choose freedom. So why should any commitment to that ideal be considered excessive?
The next example of hostility is the name-calling that happens from time to time. Free software advocates are sometimes called zealots, as explained above. But several other names are also in use.
The first, and probably most offensive, is “freetard”. This term is particularly bad because it also perpetuates the use of the term “retard”, which is itself extremely offensive. But tying that term to the honorable choice to be free seems especially wrong. Implying that digital freedom is caused by some lack of mental capacity simply doesn’t make sense.
The next term is “bully”, used sometimes by people who seem to think free software advocates are too insistent. This is a bit strange, too, since most of the tactics used by the majority of free software advocates are very passive. This term was probably brought on by some of the more controversial tactics used by the Free Software Foundation, which itself tends to use name-calling on occasion. But that organization, while very important, does not dictate the actions of the rest of the community. Their philosophy articles are helpful, and they have good ideas, but their actions don’t need to reflect on all free software advocates.
The last term people use, falsely in my opinion, is something similar to “communist”. Now, this particular example may not be terribly offensive, since the days of the Cold War are gone. But using terms that are untrue doesn’t help anyone. I hope to soon write further on this subject, but to briefly summarize, free software allows for too much freedom among people, and the free market would soon bring people to release their own versions of things, possibly for money. Socialism and communism, and similar systems, wouldn’t be fertile ground for software freedom; or perhaps more appropriately, free software wouldn’t be contained by those systems for very long. This is pretty clearly caused by the “open source” branch of the movement, where people emphasize giving back to the community, and communal ownership of the creative works in the society, but even that community appears to be more motivated by capitalistic intentions than anything else.
There are a few possible reasons listed above, but I’m hoping to come to a more unified theory, since none of the individual incidents seem to be self-explanatory.
One idea I had was that people might be seeing free software as a threat to the software industry. Many people confuse “free” as being mostly related to the price of the software, so their hostility might be caused by a concern that profits would be lost if free software took hold. Of course, Making Money Ethically is a potentially helpful solution to that concern, but very few people understand the concepts set forth there, and even fewer would consider actually implementing those concepts.
In closing, I’d like to reiterate my call for feedback. I don’t know why people react the way they do to free software advocates, but I’d like to revisit this question with some more interesting data. If you think you have an answer, I’d love to get an email from you. If you think negatively about the free software movement in some way, can you trace your perception back to something concrete? Please contact me with any information you might have, and if possible, indicate whether you’re comfortable having your email reprinted on this blog.
Thanks for reading, and as always go freely!