Unfortunately, I forgot to bring my camera, so here just a few links:

• flickr
• slideshare
• blogs

When reading the book Open Sources: Voices from the Open Source Revolution, I found the following answer to the question by Robert Young:

“That question assumes that it is easy, or at least easier, to make money selling proprietary binary-only software.

This is a mistake. Most software ventures, whether based on free or proprietary software, fail. Given that until very recently all software ventures were of the proprietary binary-only kind, it is therefore safe to say that the IP (Intellectual Property) model of software development and marketing is a very difficult way to make a living. […]

No one expects it to be easy to make money in free software. While making money with free software is a challenge, the challenge is not necessarily greater than with proprietary software. In fact you make money in free software exactly the same way you do it in proprietary software: by building a great product, marketing it with skill and imagination, looking after your customers, and thereby building a brand that stands for quality and customer service.” (chapter 9)

The fact that it’s very difficult to make money with proprietary software is probably even more true for China. In a country in which nobody is actually willing to pay for software, the question should not be: “How can we make money with FOSS?”, but rather: “How can we make money with software?”. But let’s first continue looking at the original question. As Robert Young puts it, in some cases using FOSS can even be a competitive advantage:

“Marketing with skill and imagination, particularly in highly competitive markets, requires that you offer solutions to your customers that others cannot or will not match. To that end Open Source is not a liability but a competitive advantage. The Open Source development model produces software that is stable, flexible, and highly customizable. So the vendor of open-source software starts with a quality product. The trick is to devise an effective way to make money delivering the benefits of open-source software to you clients.” (chapter 9)

This is exactly what I tried to say when I tried to answer the question. I told them that FOSS allowed them to start off with a high-quality source base rather than reimplementing everything from scratch, that open source made it easier (and affordable) to build highly customised products, I mentioned that in the West many businesses have been created because of the relative low cost of building software on top of FOSS. However, all these explanations were countered with more questions and strange looks.

Today, I believe that Robert Young does successfully answer the question of how to make money with FOSS. I also think that my answers were not totally wrong, though I simply missed one important fact: That making money with FOSS doesn’t have to be harder than making money with proprietary software. And thanks to Robert Young, I believe that the real question should be “How can we make money with software?”, and more specifically, “How can we make money with software in China?”.

• Language is an impediment. Most FOSS activities take place in English.
• There is no culture of innovation in China.
• The discussion culture in FOSS projects is too confrontational.
• FOSS is still too young in China to be successful.
• There is only little support for FOSS in the Chinese software industry. Piracy has a negative effect on the creation of a proper software industry in general. Customers are not willing to pay for software.
• Students don’t learn about FOSS at universities and hence don’t know about it.
• Individuals can’t make money with FOSS in China.
• Chinese government policies are not favourable towards FOSS.

These hypotheses are an extension to the ones presented in an earlier entry I have posted in February. They are specifically applied to China (because that’s the country I am currently studying) rather than Asia in general, though I do think that most of them could be applied to other countries like Thailand too.

Despite the fact that these hypotheses are rather negative in their formulation and might have some other shortcomings, I believe that they provide a good basis for further discussions. Also, hypotheses are there to be proved or disproved, they don’t need to be valid in the first place.

Why am I posting this?

Because I would like to get some feedback. I would love to know if there is something completely wrong with them, if I have totally missed the point, if I have forgotten something important, or anything else you have thought of while reading them. Please let me know :).

Madelaine Akrich, Comment décrire les objets techniques?

Later in her paper, Madelaine Akrich introduces the term “script” to refer to the behaviour of a technical object. The “script” is the program which the original developers write in order to define how the object can be used by its users.

For the purpose of studying FOSS in Asia, the technical object would be a piece of FOS software, its behaviour is defined by the source code, and the users are people who are using this software from within the borders of what is defined as Asia.

However, the scope of my master thesis as described above is not complete. FOS software has a specific characteristic which is related to it’s licensing terms. I don’t want to enter into FOSS licensing in detail, but I would like to emphasise one interesting aspect of open source software: modifiability. This means, we can take a piece of existing FOS software and tailor it to our needs. Going back to Madelaine Akrich’s definition of the “script”, this means that the “script” can be modified by its users. We are thus moving away from the traditional developer-user model to a more distributed open source community development model. In FOSS, users are not stuck with a pre-defined script, rather they are encouraged to change the script according to their needs. This in turn, forces users to think about the software in terms of its utility to an individual.

To be honest, the source code or “script” cannot be changed by any random user. Instead, this freedom is restricted to people who are familiar with computer programming. However, FOSS has made it easy for users to give feedback, propose new features, and report bugs. You don’t need to be a programmer to do this, though you still need to be able to use a computer and run the program.

Implementing modifiability into objects is not new, although the open source movement and its derivatives have been strongly promoted lately. In his book Two Bits, Kelty investigates the impact of modifiability on culture, he writes:

But what is the cultural significance of modifiability? What does it mean to plan in modifiability to culture, to music, to education and science? At a clerical level, such a question is obvious whenever a scholar cannot recover a document written in WordPerfect 2.0 or on a disk for which there are no longer disk drives, or when a library archive considers saving both the media and the machines that read that media. Modifiability is an imperative for building infrastructures that can last longer. However, it is not only a solution to a clerical problem: it creates new possibilities and new problems for long-settled practices like publication, or the goals and structure of intellectual-property systems, or the definition of the finality, lifetime, monumentality, and especially, the identity of a work. Long-settled, seemingly unassailable practices — like the authority of published books or the power of governments to control information—are suddenly confounded and denaturalized by the techniques of modifiability. (page 12)

Modifiability is at the core of FOSS. It’s one of the main reasons why FOSS communities have emerged. It’s at the base of almost all discussions on mailinglists, forums, IRC channels and FOSS events. The users and developers can decide the future of the software by participating in these discussions. The fact that a FOSS culture has emerged around open source software, proves Madelaine Akrich’s point that technical objetcts are important elements in the construction of cultures. And, of course, despite it’s modifiability, FOS software has a “script” which clearly defines how it’s supposed to be used

Samuel Herzog will be in Beijing until Saturday July 19th, if you are interested in taking him through your favorite part of Beijing, you can contact him at hoio[at]bluewin.ch.

• FOSS is legal to use, copy, modify, and distribute. Especially in China, where new laws can be enforced within little time, this can be a considerable advantage. However, it doesn’t seem that anti-piracy laws will be enforced anytime soon.
• FOSS can be modified to meet the exact needs of the users. This is impossible with proprietary software.
• FOSS has always been free, and FOSS-based companies have always been forced to come up with different business models. Hence the Chinese situation is not that different from other countries.

The question is: If people don’t pay for software, will they pay for customisation of open source code? Are they willing to pay for services and support related to the software?

So far it seems that FOSS in China is mainly about talks, about promotion, about words, not that much about code. When it comes to software, China and Thailand are special cases: Software is generally available for free or little money, independent of it being open source or not. Piracy is omnipresent, licenses don’t exist. It seems almost impossible to make money with software development in China. People just don’t want to pay for it.

Questions

How does this influence software development in China? Are there new business models emerging from this? Is there a need for China to have a software industry at all? How does it influence innovation and creativity? How do existing software development companies survive? What about web (2.0) development?

Event:  BeijingOpenParty July: Summer Daydreams (仲夏梦舞)
Date: July 19th
Time:  13.30 - 17.30
Address:  Room 1105, 11th Floor GuoHua Plaza, No.3 Dongzhimen South Street, Dongcheng District, Beijing, China, 100007, see map.

models.py

from django.db import models
from django.utils.translation import ugettext_lazy as _
 
class AccessibleCaptcha(models.Model):
    question = models.CharField( max_length=255)
    answer = models.CharField(max_length=255)
 
    question.verbose_name = _(u'Question')
    answer.verbose_name = _(u'Answer')
 
    def __unicode__(self):
        return self.question

fields.py

from random import randint
from django.newforms import *
from django.utils.translation import ugettext_lazy as _
from django.utils.safestring import mark_safe
from captcha.models import AccessibleCaptcha
 
class AccessibleCaptchaWidget(Widget):
 
    def __init__(self, options={}, *args, **kwargs):
        super(AccessibleCaptchaWidget, self).__init__(*args, **kwargs)
 
    def render(self, name, value, attrs=None):
        index = randint(0, AccessibleCaptcha.objects.count()-1)
        accessible_captcha = AccessibleCaptcha.objects.all()[index]
        question = accessible_captcha.question
        return mark_safe(u'''<strong>%(question)s</strong> 
<input name="%(name)s" value="%(index)d" type="hidden" />
<input name="%(name)s" id="id_%(name)s" type="text" />'''
                % {'name':'captcha', 'index':index, 'question':question})
 
    def value_from_datadict(self, data, name, prefix):
        return data.getlist(prefix)
 
class AccessibleCaptchaField(Field):
    def __init__(self, required=True, label=None, help_text=None,
            options={}, *args, **kwargs):
        super(AccessibleCaptchaField, self).__init__(required=required,
            widget=AccessibleCaptchaWidget(options=options),
            label=label, help_text=help_text, *args, **kwargs
            )
 
    def clean(self, value):
        errormsg = gettext(u'You did not enter the correct answer. Please try again.')
        if not isinstance(value, (list, tuple)):
            raise ValidationError(errormsg)
        #get the right answer from the database
        #value[0] contains the id of the hidden field, value[1] contains the user input
        index = int(value[0])
        answer = AccessibleCaptcha.objects.all()[index].answer
        if not value[1].lower() ==  answer.lower():
            raise ValidationError(errormsg)
        return True

Usage

captcha = AccessibleCaptchaField(label=_(u'Are you human?'))

Technologies applied included: Pike, OpenGL, Flash, Chipmunk, Twitter, cURL, Festival, C, Boarduino, Arduino, LED, and many more.

Update: Martin has offered me to add his pics to my flickr account. Thanks, Martin :).