Over a million developers have joined DZone.

My Views on Open Source

DZone's Guide to

My Views on Open Source

· ·
Free Resource
At the end of one of my recent blog posts, I stated that I’m not going to release Behistun, the software powering my blog, as an open source project. Since I’ve engaged again in some open source projects in the past few weeks and I feel that my views on open source have changed in the past couple of years, I thought that it’s worth writing a blog post to describe why I don’t want to start an open source Content Management System (CMS) or a blog engine in that matter, and generally, describe my views on open source that I earned in the past years.

Before talking about my views, I’d like to note that these are my own views based on my experience and contributing to open source and reading about it, and they should be different from someone who hasn’t engaged in this or has had different experiences, however, I guess that some of these points are helpful in correcting some wrong beliefs about open source.


One of the major reasons for failures, problems, and flaws in human’s life is that we emphasize much on what rather than why in our works. We start many things and perform many acts without asking ourselves why we are doing that and spend a lot of time and effort on what to do and how to do it. The same point applies to open source. There are many active and inactive open source projects that are started without answering the simple question that why they need to be started and continued.

As I’ll describe later, open source projects can roughly be categorized into two major groups of one-time and long-time projects where knowing the why is not much important for the former group unlike the latter one. A long-term project needs to be developed, maintained, and supported in a long term, so it’s very important to convince yourself (and perhaps others) why you want to start a project like that.

For example, there are many open source and shared source CMS projects with different features for various platforms, and in fact, CMS and blog engine projects can be considered as the top category of open source projects for any platform and a de facto standard for open source community. From a different view point, a CMS is like a Hello World application for a platform in a bigger scale. Of course, the level of sophistication may vary from project to project but less or more, all of these projects offer all the main features that somebody’s looking for. Now as a programmer, I have to ask myself why I need to start an open source CMS project to add to this world. Am I adding anything new that is really needed by some people? If I’m really looking for something that I couldn’t find and want to write my own (as I did with Behistun), perhaps it’s just me and there aren’t many other people in need for that.

Furthermore, in many cases, even if a product is close to what I need and it lacks some features, I am able to add those features and contribute it back to the original rather than starting a new one. This has been like a poison wasting the efforts on the open source community especially for Microsoft developers.

I can’t count the number of famous .NET projects that were hot and popular for a while and died as a very similar project with some new features came out and the founders hadn’t answered that simple why question. You can just think about many projects available for O/R mapping, mocking, unit testing, and IoC, and how they provide very similar features without major additions. Here one contributing factor may be the licensing and providing a more flexible one but on the .NET community it’s not usually the case as most of the similar open source projects have licenses that are offering same limitations in their licenses.

One-Time vs. Long-Time Projects

Open source projects can be classified in two major categories of one-time and long-time projects. By nature, some projects are developed once and used for a very long time with no modification and maintenance because their logic and API don’t need to change. For example, the libraries built for online services like a library for Google Prediction API can be implemented once and be released once as the original service specification will not change often. Likewise, an implementation of an RFC standard or a set of security tools usually don’t need ongoing support and modification. In contrast, there are long-term projects like CMS or blog engine projects that need to be updated, modified, and expanded in the long term and they take more effort for this.

Interestingly, one-time projects are reused many times in other software systems even in other long-time projects and I believe that they play a more important role in open source. One-time projects have the advantage that answering to the why question for them is easy because they are usually developed when there isn’t a similar project available and you hardly can find two one-time projects targeting the same goal. Additionally, they don’t need maintenance and support and with a satisfactory documentation you’re done with the project.

I strongly believe that more effort should be dedicated to these one-time projects in open source specifically for the Microsoft community because we lack such products that can be very helpful for all programmers and users. Therefore, if I want to work on an open source project, I’ll try to work on such ideas to do something more useful.

Open Source vs. Commercial Software

For me open source is not the opposite of commercial software neither it is something exactly in the same direction. I believe that open source, particularly open source on the .NET community, should be combined with some motives (that directly or indirectly relate to money) in order to succeed, otherwise it has a high potential to fail sooner or later (as I will explain later in this post), and the past experience has proven this in action. Here the art is to have a delicate combination of commercial aspects and open source to not let one outweigh the other because losing the correct balance is also a good potential for failure.

I can write a separate post about this but essentially, there is a wrong belief that open source is a competitor to commercial code. Instead, it’s a good complement for commercial software to reduce the costs and improve the quality.

Importance of Open Source for a Programmer

The other point that I’d like to mention here is about the importance of open source for a programmer. Whether you’re a commercial software developer or a researcher who writes code for his own needs, you never get to climax unless you actively contribute to open source. I personally don’t trust on any programmer who doesn’t have a solid open source resume and I put much emphasis and respect on somebody who contributes any programming code to an open source project.

In my experience, active contribution to open source helps you learn a lot and practice many skills that you never can learn in industrial or academic programming because in these environments you’re stuck with a classic format of software that is usually a data-in/data-out system that has common requirements and doesn’t need you to do any special work. I personally learned a lot from open source and that’s why I strongly believe in it.

Open Source vs. Shared Source

Many people have the wrong understanding of the concept of open source and they mistakenly view shared source projects as open source while this is incorrect. Seeing the source code of a project doesn’t make it open as some Microsoft licenses are trying to impose. In fact, the main supporter of the concept of shared source code is Microsoft, so this is the problem with the Microsoft community more than other communities.

Open source is not only about a real open license but also about the passion for openness and desire to do such a work. Having this view, there are many projects that fall into the category of shared source and these are the type of projects that end up being inactive and fail after a while.

Support and Maintenance

Some people have the misbelief that open source is just about releasing the code to public and forgetting it. This works for one-time projects, but it’s the worst idea for a project that should be maintained and supported in long term and a good example is a CMS.

Photo taken from http://www.thetechherald.com/media/images/200911/OpenSourceCode.jpgIf you do it right, you will have users for your project and this brings responsibility to you, and you’ll need to respond to feature requests, bug reports, and questions. This is equal to future development and ongoing support which mandates time dedicated to the project. If you don’t see yourself having much time available to spend on your open source projects, you better avoid starting them and leaving some users alone with the troubles to either leave your product or find a way to continue it.

Most likely, you’ve seen many projects like this that are started but not maintained actively and you’ve tried hard to find an answer to one of your questions or a way to add a new feature that you need.


Again, one of the common misbeliefs about open source is that it’s just about coding and releasing the code, and not caring much about how you’ve written that and how you let others use your code. The success of an open source project heavily relies on the quality of the project (other than the features it provides) and one important measurements of quality that is more important in open source is the documentation. This documentation includes the code comments to allow somebody else to modify your code and build upon it in the future which enables better opportunities for the future of your project with other programmers contributing to the code. It also consists of standalone documentation on how to use the product, install it, diagnose the common errors, and similar issues.

It shouldn’t be forgotten that open source is not only for technical people in the same field. There may be less technical people trying to use an open source product (e.g., a CMS). If you’re writing an undocumented code, then you have less chances to get users no matter how good you develop your project.

Once again, I have to stress on the point that not only documentation helps others use your product, but also it helps other developers understand your work and contribute to your project which is vital for the success of such a project in future.

Time and Effort

If we look at open source as providing new opportunities with least hassle for other programmers and users to have access to software, it is important to dedicate our time and efforts to all aspects of open source rather than a few topics that are hot and may help us achieve some commercial or reputational goals that we have. Unfortunately, open source on the .NET community has been developed more like that around a few topics while the efforts could be organized to provide many ideas that are not available on the .NET community.

Comparing the Java community with .NET, this is an area where .NET sucks big time and you can’t find many open source projects that are really needed. For example, there hasn’t been much work on open source projects on security in .NET which is a very common and important aspect of programming, as there hasn’t been any on building a rich set of compiler tools preventing the .NET framework from being used for such purposes.

With a very limited time that I have, I’d prefer to spend it on such ideas and develop something that will be useful and doesn’t have an alternative rather than releasing yet another CMS, blog engine, O/R mapper, or IoC container.


There should be good motives for starting an open source project or contributing to one, and this is a part of answering the why question that I wrote about. For a long time, I was trying to develop open source projects only for the sake of helping others forgetting the fact that I’m spending my invaluable time on them and there should be something about myself as well. People are using my codes, articles, books, and many other works to earn money and reputation while there is nothing coming back to me. This was a lesson that I learned by paying too much but I finally learned that I shouldn’t do something unless there is a benefit for me in it.

Open source is not different and now I believe that we should view open source as a win-win game for the programmer and user, so the programmer earns something in terms of money, reputation, or networking while giving the opportunity to a user to use his code for free. If you have strong motives for doing something, you’ll keep doing it and it’s good for the product as well because if you lose your motivation to work on an open source project, you’ll forget it and it will die.

If you think about many open source .NET projects that succeeded in the past years, you’ll easily notice that they had such good motivational background with a main emphasis on the founder of the project because the founders could enhance their career with those projects significantly. Many of such developers were hired by Microsoft along with the project or as someone working on similar products, or they could make a better reputation finding good positions at bigger companies.

Sometimes professional programmers write open source code to show off and challenge others and that’s something that I strongly disagree with. Spending your time on writing a code to show your strengths while others will use your code for their advantage will make you frustrated in the long term because after a while, you’ll realize that nobody really cares about your strengths as long as they can easily use them for free. People don’t notice the value of something unless they pay for it.


I wrote this post not only to bring some points to people’s attention to make them rethink twice before starting a project but also to unravel some aspects of open source that people neglect and have been hurting open source especially on the Microsoft community. Open source, if used in the right way, has a great potential to enhance the software world and improve the quality of our lives, and it’s not there to compete with commercial software but to complement it.

Unfortunately, the .NET community hasn’t had a very good history and progress with open source as other communities have, and it has moved more towards shared source rather than open source, and around some particular areas rather than all areas.


Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}