With Open Source Spirit, Everybody wins by s1222207


Open source softwares are programs that are released under certain licenses which provide source code of the program, allows the program to be modified and freely redistributed. Upon invention, open source softwares are most commonly regarded as charity work given by generous programmers who like to work hard and enjoy programming. When it comes to economy, people tend to have an ingrained believe that the source code of the software should be considered as top secrets and adopting Open Source Model will bring more difficulties for company to survive. However, this is not the case. For example, in 2008, Standish Group stated that by adopting the open-source model, around 60 billion are saved every year.[1] This article will introduces several perspectives that why everyone could gain benefits with open source software.

User’s view

To users, a program claimed to be open source software is promised with freedom on how the software is going to be used, where to use it and how long they are going to use it. Also there is no limitation about sharing the software with others. General speaking, users are quite happy with softwares with characteristics, such as freedom, and will be quite understandable even if the software could only satisfy their basic needs or there are some bugs existed. Furthermore, being able and willing to give the source code to public indicate the confident of the company or programmers have on their software that there won’t be any potential security risks such as hidden spying functions programmed in their software. Therefore, Open Source Softwares are welcomed not only by normal users but also organizations with huge concerns about security risks. Some might argue that open-source Softwares are less secure than proprietary software since it is easier to find bugs by studying the source code. It is true that the visibility of source code gives attackers more information to determine the weakness of the software. One the other hand, it also gives defenders same a mount of information on how to increases the security of the software. And unlike proprietary software, open-source software gives users or developers abilities to improve the security as they want without any limit. In this case, the security of the software is not only simply influenced by company, but also by the need of users and dedication of developers. We could believe that if the software is indeed useful for a certain mount of people. There should be more programmers stand up to defend for the software rather than destroying it.

Developer’s view

When developing open source software, programmers don’t need to worry about piracy since their software can be freely used and redistributed under same or compatible licenses. Similarly, with compatible licenses, a lot of time and efforts could be saved by reusing existed open source programs. Moreover, due to the visibility of source code, users of that software could be regarded as testers who is able and willing to provide detailed information. Furthermore, experienced users with programming skills could also provides certain amount of contributions through communities or online repositories.

With Open Source Model, individual developers are able to not only contribute to existed softwares but also realize their own ideas or even start a career. By writing an initial version and pushing it to online repository, other programmers with similar interests and skills might be able to give their contributions to enhance this project. One good example is the Linux Operating System which was created in 1991 by Torvalds Linus.[2] Upon creation, the only architecture it supports is 386 (486) AT clones and there were only two programs ported, bash and gcc.[2] Then, the adoption of open source software developing model gives Linux opportunity to grow continuously by receiving contributions from programmers around the world. After 20 years, in the year of 2013, for Linux Kernel only, there are more than 16 million lines of code.[3] Moreover, most of the servers are running Linux [3] and more than 95% of the worlds’ 500 fastest computers are running Linux[4]. With open source model, Linux has eventually grown from a personal interests to a large software which has a great influence around the world.

Company of view

By giving source code to public, company first build a good reputation to customers that they are confident with both the surface and what’s underneath their software. With adequate quality and free price, this software will be soon popular among the customers. Along with the increasing popularity, more and more new customers are willing to try it. Consequently, this open source software acts as an cheap or even free promotion for the company which could lead to bigger market share. Then, other services or products that works around this software will all be benefited.

When an proprietary software released, some customers need to accept that not all requirements can be met, not all platforms can be supported and not all features will be added in future development. In this situation, the customer service of this company will be in a hassle for answering different questions and demanding from customers. On the contrary, by providing the source code and a well written documentation, experienced programmers are able to implement their own modification, adding new features or porting the software into other platforms. With the help of online repository such as github or bitbucket, programmers could even work collaboratively as well as efficiently as a team which produces high quality codes with well documentations. Therefore, the company will not only benefits from their volunteering contribution but also will be inspired by new ideas which eventually makes the product better fits users’ needs.

In addition, the open source software has a strong vitality. Even if the software is no longer supported by its creator, other programmers could keep improving it. Due to this characteristic, once an open-source product is released, other business partners are able and more willing to make contributions to it since it won’t be suddenly withdrawn or outdated. One good example is Android Operating System from Google. Being released under Apache license enables Google and its hardware partners to work collaboratively which greatly increase the popularities of Android Operating System. In the third quarter of 2013, 81.3% of global smart-phone market share was taken by Android devices.[5] Moreover, a variety of different number of distributions, created by individual programmers or organizations, indeed satisfy different demanding of users and make the Android Operating System even more popular.


With Open Source Model, everybody benefits. Users are provided with softwares which have no restrictions on how they can be used, can be trusted with security and privacy concerns and promise to be developed for a long term. Developers can not only develop open source softwares, but also modifies and redistributed them without any worries of piracy. Moreover, by adopting Open Source Model, any new ideas could be quickly initiated and developed collaboratively. Companies providing open source softwares will have a better reputation, larger market share, better relationship with business partners. And the fact that volunteers are able to contribute results in huge amount of save in developing, testing and supporting the products.


[1] Rothwell, Richard (2008-08-05). "Creating wealth with free software". Free Software Magazine. Retrieved 2008-09-08.

[2] Torvalds, Linus Benedict (August 1991). "comp.os.minix". Retrieved 2009-09-06

[3] "Linux Kernel Development: How Fast it is Going, Who is Doing It, What They are Doing, and Who is Sponsoring It (2013 Edition)". Retrieved 2014-02-23.

[4] "TOP500 Supercomputer Sites: Operating system Family / Linux". Top500.org. Retrieved October 23, 2013.

[5] "Android tops 81 percent of smartphone market share in Q3". Retrieved 4 November 4, 2013.

Response to Article: “Version Control: Important for Individual Projects?” by s1222207

This a response article to the article "Version Control: Important for Individual Projects?" by s1222207.

The main purpose of this article is to discuss about the advantages and disadvantages of using version control when working individually. First of all, the basic concept of version control is introduced. Then, the main functionalities of these kind of software are described followed by explaining in what circumstances will these kind of tools be used. Thirdly, advantages and disadvantages of using version control for individuals are given in the discussion session as well as the personal experience. At last, conclusions are given that even though version control is not necessarily needed for individual programming, it is still useful and will make life a lot easier. Ultimately, I am agree with most of the points made by this article. So this article serves as an enhancement to the target.

The discussion started by introducing the importance and benefits of using version control when working in a team that it enables team members to work at different time, in different locations while still be able to maintain the project in an organized way. Then, followed by a conclusion that

These advantages do not apply for an individual developer

I would argue that this conclusion seems to be insufficient. When working individually, it is true that all of the programming work are carried out by one programmer and there is no other communication needed. However, there might be cases that the programmer need to work on different machines.
To solve the synchronization problems between machines and even develop same program targeting on different platforms, using version control techniques and online repositories seems to be a rather good choice. By utilizing functions like merge, branch, rebase and etc, a huge amount of time and efforts could be saved.

Then, the article discussed about the benefits of being able to keep every thing recorded in commits and revert back to previous version. I am strongly agree with the first part that when developing new features of a program, knowing that there is always a working version backed up will definitely make the development process more enjoyable and with less worries of breaking the code. And I would say it is still beneficial for individual programmer to know what has been done, when and where did it happen simply because when programmer need to revisit the program finished long time ago, with the help of commit messages and notes, it will be a lot easier to understand the program again and recall why it is done this way.

At last, this article also argues that sometimes misuse of version control could cause some errors which eventually break the program. It is true that potential risks exists when introducing new concepts of software control and before mastering the version control, it is possible to cause unrecoverable damage to the code by accidentally use wrong command. In this case, I would suggest to use version control with online repository is a good choice and always have a separated backup on separated location.

To conclude, when programming individually, version control is highly recommended because it gives the programmer chances to revert back from a mistake, maintain different versions of the program, implementing new features without breaking the current working code and etc.

Software testing: an overlooked process during software development

On July 4, 1996, a cluster, powered by the Ariane 5 rocket, was ready to launch on its first journey. Thirty senven seconds after firing, the rocket went off the track and ended in self-destruct as shown in Figure 1. According to Dowson, this accident, known as one of the world's most extravagant failure, costs more than 370 million dollars.[1]

Figure 1: The Ariane 5 explosion

Analysis shows that the rocket system crashes due to an overflow when trying to convert a 64-bit floating number into a 16-bit integer. The inertial reference platform of Ariane 5 is directly reused from the one on Ariane 4 whereas the flying conditions are relatively different between these two models. In this case, the higher horizontal acceleration of Ariane 5 rocket resulted in the overflow. Sadly, due to lack of analysis and tests, the error was not discovered before launch.[2] In other words, there might be chances to avoid this tragedy, if more robust software testings are designed and performed. In fact, the lack of testing is not only a problem in large projects cooperated internationally; It is a habitual behavior that existed deep in the bone of most programmers which stops them producing code with better quality and design. This article will re-emphasize the importance of software testing and introduce the steppingstone of this approach, unit testing.


Software testing is a process or quantifiable way to identify the robustness, correctness and other aspects of a piece of software.[3]
It mainly verifies:

  • if software behaves as expected
  • how well it performs

Motivation & Benefits

Upon finishing a piece of codes, try to answer the following two questions first:

  • How to make sure that the program works?
  • How to prove its correctness to others?

Rather than directly compile and run it on your personal computer and tell your friend to watch, there are better ways to demonstrate it: software testing. With this approach, it is possible to reduce the number of errors, increase the efficiency for debugging and moreover, not only the quality of the program improves, huge amount of time and efforts are saved from finding hidden bugs which eventually makes all people's lives better.

Different Types of Testing

Rather than rush into the design and development phase, software testings should be carried out at the beginning of the project as well. Instead of perform a single test with the hope of finding and fixing every bug in the end, it is encouraged to carefully design and frequently perform testings during the project. Sometimes, spotting and fixing hidden bugs in earlier phases is significantly easier than doing that in the final stage and by continuously perform testings, it is much cheaper to fix a bug.

General speaking, tests should be applied individually, in groups and eventually to the whole system. That is, software testings could be typically divided into:

  • Unit testing
  • Integration testing
  • System testing
  • Stress/Load testing
  • Acceptance testing

In this article, unit testing, the steppingstone of all software testing techniques, are particularly introduced.

Unit testing

Testings designed for an individual component, such as a method or a module of a software, are called unit testing. By directly verifying the low level behavior of the program, unit testing could easily isolate certain part from the whole program and check its correctness. Ultimately, with this approach, we are able to fully concentrate on a small piece of code and try to identify any potential error or bug affecting the program. Especially when implementing complicated algorithms, this approach is extremely helpful.

Since unit tests focuses on the low level of the program, sufficient understanding of the program codes is needed. In most cases, these tests are implemented by programmers themselves.


This section gives a rough idea about how unit testing are performed using in Java. Please notice unrelated codes such as package importing are omitted. Given a class, named Target, declared as follows:

public class Target{
    public int multiply(int n1, int n2){
        return n1 * n2;

It has a method called multiply which calculates the multiplication of two input integers. In order to check the correctness of this method through unit testing, the following Java code are implemented:

public class testTarget{

    public void testMultiply() 
        Target t = new Target();
        int x  = 1 ; 
        int y = 1;
        assertEquals(1, t.multiply(x,y));

Here, the testMultiply method is implemented to check the correctness of the method multiply. Declaring both integer variables x and y equal to 1, it will try to evaluate whether the calculated result of method multi is also 1. After running this test in JUnit, result are presented as shown in Figure 2.

Other cases can also be considered, such as:

  • x = 1, y = 0
  • x = 1, y are declared as null
  • x = 0, y = 0
    Figure 2: The result of unit testing

Advantages and Disadvantages

One of the big advantages of embedding unit testing early in the development cycle is that hidden bugs can be traced easily and is relatively cheap to fix. Then, by keep designing new tests for both existed and new code, to a certain stage, a complete testing environment can be built. At that point, if anything has changed, the program can still be easily re-evaluated with old testing suite. By using test-driven approach, programmers tend to write test-friendly code which improves the design of the program and make the whole development more efficient.

However, there is no silver bullet in software development. The same is true for unit testing. Focusing only on one piece of code, it is unable to catch errors between integrations among different modules or classes. In this case, Integration tests should also be performed as a complementary practice. Moreover, designing and implementing tests need time, especially for large project. In some cases, the time and efforts needed for designing and implementing tests are often more than coding the actual project.[4]
Alternatively, tools like Junit and CPPUnit can be used as assistants for generating testing code.


To all software components, code quality is considered as one of the key factors which can be increased by performing software testing.
Among different testing techniques, unit testing is the one that directly check on the low level of the program, often implemented at the early stage of the development cycle and gives the programmers confidence on their codes. However, time and efforts are required for implementing well-designed tests. It is important to find a balance between developing the actual program and implementing testings.


[1] Dowson, M. (March 1997). "The Ariane 5 Software Failure". Software Engineering Notes 22 (2): 84. doi:10.1145/251880.251992.

[2] Nuseibeh, Bashar (May 1997). "Ariane 5: Who Dunnit?" (PDF). IEEE Software 14 (3): 15–16. doi:10.1109/MS.1997.589224.

[3] Myers, G.J. and Sandler, C. and Badgett, T.. The Art of Software Testing. Wiley. 2011 http://books.google.co.uk/books?id=GjyEFPkMCwcC

[4] Cramblitt, Bob (2007-09-20). "Alberto Savoia sings the praises of software testing". Retrieved 2007-11-29.