Martin Michlmayr: Corporate participation in open source communities
Someone recently asked me a few question about corporate participation
in open source communities and I thought I'd share my thoughts on this
topic here.
Are there differences between an open source project done for a
corporation and one done for personal reasons?
There are many different ways to run an open source project, led by a
corporation or by someone else. Some projects that are run by
corporations have few outside contributors. This is often the case with
projects that require copyright assignment (i.e. contributors have to
assign their copyright to the corporation). These projects may not gain
all the benefits of a true open source community, such as outside
contributions or high levels of peer review. However, they may still be
very successful projects and may have high levels of quality.
Projects done by a corporation may have better planning and may have
more resources than other projects. When a corporation, especially a
large one, starts or becomes involves in a project it can also give
credibility to the project and attract a lot of interest to the project.
This means that projects done by corporations may have a bigger impact
and might also be more visible in terms of publicity.
How do corporations successfully utilize an open source
community?
Corporations can benefit from an open source community in many ways.
For example, they can often find people who will review their code or
make code contributions. If people become excited about what the
corporation does, they might also spread the word and create viral
marketing for the corporation. Establishing a community around one's
project is often also a good way to identify people to hire since you
already have experience working with them and know their capabilities.
How do open source communities successfully utilize their corporate
relationships?
Corporations can make several unique contributions. For example, large
corporations can use their name to attract attention to a project and
give it credibility. Furthermore, corporations have some capabilities
that personal contributors often don't have access. They may have
special testing equipment (such as servers with thousands of CPUs or
hard drives) or access to a testing lab where a professional usability
test can be done. Finally, corporations can sponsor developer
conferences, which are typically very effective means for the community
to come together and work on activities together.
It is important for projects to remember that corporations are not
charities and that they will invest in an open source project for a
reason. Therefore, they have to ensure that the corporation will get
tangible outcomes from their involvement or sponsorship, otherwise they
may not stay involved in the long run.
What are the risks for a corporation when working with an open
source community?
One risk is that the code (or other form of contribution) is not
accepted. However, this is a risk any contributor to a project faces.
Before making any sort of contribution, it is therefore important to
become familiar with the project and its culture. Every project has
their own "do's" and "don'ts" that have to be followed.
Another risk is that a corporation will invest in a community project
that later on is abandoned by the community. However, in this case, the
corporation could take the lead and continue to maintain the project.
What are the risks for an open source community when working with a
corporation?
One potential risk is that the corporation will assert too much control
over the project. It's important for projects to ensure that the
community as a whole has influence over the direction of a project
rather than one particular player.
Are certain certifications needed in order for someone
to participate in open source projects for a corporation?
Certifications are not needed to get involved in or start a project.
However, it is important to become familiar with the open source
community and the project one wants to contribute to. A good first step
is to read the book Producing Open Source Software by Karl Fogel which
is available online. As a next
step, the community in which someone wants to get involved in should be
studied, for example by reading the mailing list archives. This will
help to become familiar with the culture of a project as well as the
mechanisms to contribute to the project.
How do open source communities communicate and collaborate with
corporations?
In the best case, employees from corporations would interact in the
project like any other contributor. That is, they should use the
existing communication channels, such as mailing lists, IRC or developer
gatherings. Many companies are good at working "with the community" but
the ideal scenario is for a company to be part of the community and to
work "in the community", just like other contributors. This is the most
effective way for them to make changes to the code and project.
Of course, not every corporation will get involved in a project
directly. That's why it makes sense for projects to collaborate with
corporations in other ways. For example, projects can talk directly to
companies to get samples of their hardware in order to add support for
them in their software. Projects can also work directly with
corporations to find out how their project can better meet the needs of
enterprise users.
So, the latest buzz on the web is all about 
During this past weekend I tried to get Windows XP, Windows 7, OSX, Debian, and Ubuntu all on one machine. Due to some mishaps, driver oddities with Windows 7, and other things, I had to install certain operating systems multiple times. Now, the problem is, each operating system has it's own peculiar way of loading. Linux uses GRUB, Windows XP has NTLDR, 7 has the Windows Boot Manager, etc. Most of these operating systems also decide it would be helpful for the end-user that when his computer reboots, it can actually load the new OS. That's great, but I already have a bootloader.
This weekend I implemented an idea I had some weeks ago: sending regular mails with the translation status and the contents status of 
Trying to clap.
I've tried making a 'crowd claps' kind of sound.
I recorded myself clapping, 12 times, and mixed the sound with ecasound:
ecasound $(for A in $(seq 1 12); do echo -a $A -i "$A.wav" -y $(( A / 5 )).$(( A % 5 * 2 )); done ) -a 1,2,3,4,5,6,7,8,9,10,11,12 -o alsahw,0,0,0
However, it doesn't sound quite right, it is too sparse.
I tried mixing the same sound 12 multiple times, but it seems to make the sound stiffer but not in the way I wanted. Delay and echo doesn't get me the right tone. Hmmm..
ecasound $(for A in $(seq 1 3); do echo -a $A -i "hakushu.wav" -y $(( A / 5 )).$(( A % 5 * 2 ))$(( A % 2 * 2 )); done ) -a 1,2,3 -o hakushu2.wav
According to The Registry, 
Linux serial ports only work at standard speeds by default. MIDI runs at 31250 baud, which is not a standard speed. However there are tricks to get custom speeds, but documentation is quite fuzzy. This is a simple recipe that worked for me with an FT232 USB-Serial board.
I've already had one enquiry, so I guess I'd better get writing.
Despite the lawyers being really down on using this Consulate, I have to say
that from my experience, it's been the easiest so far. Or I'm just getting
used to the rigmarole.
The one screw up was I didn't read the instructions thoroughly enough, and
we rocked up to the Scotia Bank branch to deposit the visa application fee
in their bank account, and I thought the fee was quoted in Canadian dollars.
Turns out, it was quoted in US dollars. It wasn't the end of the world that
we didn't have cash, they could sell us US dollars on a credit card, except
the bank would only accept Visa card, not Mastercard. I haven't had to deal
with such bullshit since the great Cabcharge/Visa card war in Australia in
the late 90's.
Moral of that story: read the instructions multiple times. Carry one of each
flavour of credit card when traveling internationally, just in case.
That minor transactional hiccup aside, everything went fine. The Consulate
itself does all of the pre-interview shenanigans on one floor (the bulk of
the waiting around, the fingerprinting and photographing) and then they
shoot you up to another floor for the "interview". Annoyingly, they run you
through the metal detectors again on the higher floor.
The interview was basically "So you work for Google? How about the food?"
and then he told us to come back the next day to pick up the passports. I
think we were in and out in about three, three and a half hours.
I have to say, the ability to collect the passports from the Consulate later
is a real boon. When you're in a foreign country, the last thing you want to
deal with is any glitches in the postal system, or trying to get mail
delivered to a hotel. This alone makes me like the Vancouver Consulate the
best.
We went back at the 2:15pm allotted "passport pick up time", and they came
down to the security checkpoint on the ground floor and you show your
receipt and they give you your passports back. They tell you to step outside
and check it, and come back if there's any problems, so I presume you can at
least talk to a human at that point if there are any problems.
This is my third E-3 visa. They did not ask to see any of my supporting
paperwork showing ties with Australia or anything else that I had in my
giant wad of paperwork, just the approved Labor Condition Application, which
they kept and returned with the passport the next day.
Arrays and Generics in Java do not mix very well. In order to create an
array, you need to know the object class the array is supposed to store.Arrays in Java are special: they can efficiently store primitive data types.
The expected difference in efficiency between byte[] and
Byte[] is pretty big (of course some good VM might optimize) for
obvious reasons (think of: references, garbage collection, pointer sizes, ...).This is probably why you need to know the type before creating an array
(because an array of primitive types such as byte will be different
from one that stores objects of some kind).In particular, the following Java code
Hola all,
Yesterday I finally found some time to analyze all filesystem message dumps
for Nokia phones. I always hated way Gammu used to decode these messages,
because in most cases decoding was almost same function just with added some
random offsets.
After some time looking into the dumps, I finally came out with