Open Source Critique

Many companies lack adequate mechanisms for reporting bugs or feature requests.  Bug tracking software is rarely seen in the proprietary software world, but it is a common necessity among open source projects.

According to this article from The Good Life, Microsoft not only makes reporting bugs difficult, but they make the submitter pay for it. Perhaps they do this in effort to minimize the mass of bug reporting. But we can’t help to wonder if maybe Microsoft should be held responsible for the software that people pay for. Microsoft may have cleaned up their act since the publication of this article, so I encourage you to file a bug with Microsoft and report your findings. I believe Microsoft also has an in-software reporting system, but is it really efficient?

Benefits of a bug tracking system:

• Allows users to easily report bugs they encounter. Meaning the users can have a voice in the development process.
• Avoids repeat bug reports. In the case that a duplicate bug is reported, there is usually some sort of bug management.
• Software will be more stable. Testing in the real world will role out more bugs than the limited testing made by the developers.

There is no reason bug tracking systems can’t be used for commercial software.

The use of open source software in government institutions is slowly becoming a reality. BBC News recently published an article about this very issue. It mentions the possibility of US President Obama needing to adopt open source software to cut costs.

Such movement is not unheard of. In 2006, Venezuela passed a law mandating a two year transition to open source in all public agencies (source). While it appears they have not met their original goal, Venezuelan officials have continued to push open source software. (Vietnam and Malaysian have similarly reported moving to open source software.) Venezuela, among other nations, have shown support for ODF, an open specification document file format, instead of Microsoft’s misleading proprietary OOXML.

Why would governments chose to go open source?

• It cuts costs. There is no price tag for open source software.
• It isn’t proprietary. With proprietary software, governments may get locked in to using certain software.
• Transparency. Because source code is available, it may require governments to be more transparent. In particular, electronic voting systems should be operated by open source software.

According to this article, the French police are using some open source software “to avoid the kind of IT monoculture that allows viruses to spread and disable all key systems.”

There has been much discussion about electronic voting machines compromising the US elections (and surely this issue presents itself in some form worldwide). There are two parts to this discussion:

• Some machines are visually selecting the wrong candidate, presumably due to bad monitor calibration.
• Some machines may be secretly giving the vote to another candidate. (Even if a machine visually shows one candidate, who’s to say the machine counted that vote correctly?)

The first may be fixed by the user, while the second is secretive and more hostile. Voting transparency is important in ensuring a healthy democracy.

The US government already requires candidates to disclose their fundraising and spending. Open sourcing voting machines are not much of a stretch and utilities this similar idea of openness. This is a genuine situation where open source voting software is the most logical solution to the potential of corruption.

Clinton E. Curtis gave an interesting a testamony at a Congressional hearing in Ohio. When asked about protecting Ohio from rigged elections, Curtis replied “You would have to look at the source code… programmers from all parties to look at the source code and determine if there is anything in there that shouldn’t.”

A not-for-profit organization, called the Open Voting Consortium, has been created to encourage voting accountability. They’ve already come up with some solutions. For a more in depth discussion, check out this article, “Open source: How e-voting should be done.”

The quest of combining open source work with money has been a long one, we’re at a point at which companies are familiarizing themselves with open source software. I recently skimmed an article entitled “Open Source is not a business model.” The article has a point, but I disagree to a certain extent

Businesses are trying to adapt the appealing aspects of open source to fit a business model. A few developers are able to be payed for their previously voluntary work. The problem, as the article was pushing towards, is that this new movement is clouding the original concept: it isn’t open source anymore (as you might have guessed). Money is now the target.

I argue that this doesn’t have to be the case.

Companies want support if something goes wrong. They invest in hardware and software they can depend upon. Part of this dependency is reliable support if something goes wrong. It’s an insurance policy. (A business opportunity!)

You would then think the primary function of the company would then be to provide support. But in order for them to provide support, they need to attract businesses to the open source software in the first place. Overall, it’s a win-win for the buyer and the seller.

Or is it? Normal business models get the heads up as they make money for the sale of the license, and again for the support. Open source oriented businesses lag behind as they try to gain back losses (from development of the software) by putting more effort into providing support instead of developing the next big thing like other proprietary competitors are. This creates a loop of deterioration.

On the contrary(?). First, open source promotes itself, which cuts overall spending on marketing. Second, with no licensing fee, your product can be cheaper and thus attractive to the consumers. This may help to grow a user base faster. In the long run, a larger user base provides more income for competition.

I think overall this version of a “open source business model” may still be disadvantaged. But it in part is a system of values and beliefs. And heck, being payed is better than the alternative.

Now has been the time for many project updates. Google’s Summer of Code is over, which is an indicator for many projects that it’s time for a new release. While some are finishing up their work and alpha/beta testing, some of these projects have already been released (only recently):

• The GIMP 2.6 (Read about it.)
• GNOME 2.24 (Read about it.)
• VLC 0.9.x (They’re looking for Windows developers, if anyone is interested.)

So, watch out for these releases in the near future:

• Open Office 3.0 - Final version to be release this month (October).
• Inkscape 0.47 - Unknown release date, but it’s about time! I would expect a release between December and February.
• Xfce 2.6 - Final version to be released in mid-December.
• Firefox 3.1 - To be released by end of 2008.

Songbird is a media player based on the Firefox web browser. The media player has finally reached beta phase.

Songbird has come a long a way since it’s first release. I’ve personally had Songbird installed since the 0.2 release almost two years. And while every release has presented vast improvements, Songbird’s greatest downfall is its bugs, preventing it from everyday use.

Songbird 0.7 was particularly surprising for me because all of the problematic bugs I encountered from previous releases were finally fixed. There are most definitely some issues left, for example, video playback isn’t solid. It also seems to have some issues with add-on and feather (theme) compatibility. I installed a theme, restarted, and Songbird was terribly broken, and there was no way to “reset” Songbird. (Reinstalling Songbird refused to work, and forced me to use some clever workarounds.)

Video playback should have it’s own section. If it isn’t a music file, it belongs in the video section. This prevents issues of video playing when playing your library on “shuffle” mode. Video is a secondary feature, and should be treated as such.

It should be mentioned that some Songbird developers are being paid by a group called Pioneers of the Inevitable. It’s neat this sort of attitude. It also explains Songbird’s rather quick release cycles over the last year, which have truly improved Songbird as a media player.

Give Songbird a try. It’s a great alternative to Apple’s non-free iTunes.

Before reading any further, this article is not a review on Chrome itself, but more focus towards what the Chrome web browser offers to users and the open source world. (Many of us are sick of those mundane product reviews and new stories!) If you haven’t already, I suggest glancing at Google’s storybook/comic for Google Chrome, as it is very insightful towards the goals of this software.

If you weren’t familiar already, the principle idea behind Google Chrome was to build a browser from ground up and work back up to browser usage today. Of course, Chrome isn’t completely recoded: it uses the WebKit engine for rendering websites. But the idea is that most of the fundamental ideas behind a web browser have been rethought. (Side note: Google and Mozilla recently renewed their search partner contract for another three years. So Google has not given up on Mozilla.)

Chrome raises some questions about how current browsers work. In particular, Chrome sacrifices features for stability. Mozilla Firefox has numerous features, some of which should really take advantage of its addon system. Hopefully Google Chrome will create a new standard in terms of social engineering concepts, such as these Chrome concepts:

• Separate processes for separate tabs and plugins (like Adobe Flash).
• Fewer features, work on stability. Average, everyday users will be less confused or worried.
• The placement of the tabs. When switching tabs, it makes more sense that the address bar is part of that tab. Separating the address bar from the tabs is awkward as the address bar appears to simply change value when switching between tabs.
• Most visited or recent websites/bookmarks when opening new (blank) tabs is more efficient for the user. Users don’t need to worry about loading times if this is integrated into the browser the way it is in Chrome.
• More efficient javascript interpreting.

The Firefox team has some pretty good user interface designers who’ve been really thoughtful about improving the usability of Firefox. The Chrome team truly gives a fresh perspective. The two should get together. Especially with Google working on the Android mobile operating system, and Mozilla working on a mobile browser.

Chrome also has a developer-geared attitude, so that developers may do as they wish with the browser. This isn’t really anything new as Mozilla Prism (aka WebRunner) is the same deal. IE rules with this functionality in the Windows environment. For example, Valve’s Steam uses IE to render web pages within the application so it looks and feels as a part of the application itself. Nevertheless, the usage of IE needs to drop. And with the implementation of Prism or Chrome instead, more open source applications may emerge.

Google acknowledges using Mozilla and Webkit. It appears that they have a relatively strong bond. So, I don’t see this as a threatening browser, but it all depends on Google’s approaches as Chrome evolves. It is very much a contribution to the open source world, and I hope that open source projects will use pieces as they like. At a personal level, Chrome isn’t replacing Firefox right now, but Chrome certainly has concept ideas I would like to see in Firefox.

If you consider yourself anything of a moderate computer user or beyond, like myself, you may have realized that some open software doesn’t offer the functionality that it should have. GNOME is a good example because I think it suffers from performance and customization issues.

Types of things that need to be improved range from many things. Here’s a list of some of the more obvious, broad ones:

• Customization in terms of how features interact (with the user).
• The graphic user interface (GUI), which entails usability.
• Overall stability of the software.
• Structure of code and of the project itself.

Universities. As part of independent study classes, students could chose to help contribute to a project as part of their. Professors could shift their researching focuses to the open source world. Oregon State University and Google collaborated to provide hosting servers for many open source projects. We need more of this attitude.

Google’s Summer of Code is a promising way of getting things done. It’s helped Inkscape quite a lot, among many other projects.

Paying developers. Money is good incentive for volunteer developers, who have real jobs besides. If only we had more wealthy people who wisely spend their money like Mark Shuttleworth with Ubuntu. Open source software shouldn’t be just a hobby. I’ve heard stories of some companies providing funding to open source projects to keep them maintained because the company doesn’t want to lose their software investment.

Code Organization. Sometimes open source projects simply lack a properly planned code organization, which may create more issues in the long run. Bugs are inevitable, but a strong sense of structured code can make it easier for other developers to commit changes, too. And a strong, thought out code base may mean better performance. I think all the Tux Racer forks suffer from this.

In Universities, the community is a big thing. It’s all about the community: people from different areas of the world come together to study and have some fun. The open source community should note be taking lightly. It is probably fundamentally one of the most important reasons open source lives today for many of the same reasons. We need a diversity of ideas.

Anyway, I welcome you readers to this renewed blog. I hope this blog will encourage users and developers alike to continue to enjoy the open source community, but also to provide feedback to various open source projects. One could say it’s all for the “greater good” of this open source community. If you’re still unsure what exactly this blog is, visit later for future blog posts.