Moving to an Open Source World

Quality

Your browser needs to be JavaScript capable to view this video

Try reloading this page, or reviewing your browser settings

This video segment explains how open source quality varies greatly. Low quality programs can be poor indeed, but the highest quality examples can surpass their proprietary counterparts. This segment will also discuss how a transparent and inclusive development process can have positive effects on software quality.

Keywords

  • Bugs
  • resources
  • bad practices
  • code maturity
  • alpha software
  • beta software
  • inspection
  • diversity

About this video

Author(s)
Karl Beecher
First online
25 December 2018
DOI
https://doi.org/10.1007/978-1-4842-4441-8_5
Online ISBN
978-1-4842-4441-8
Publisher
Apress
Copyright information
© Karl Beecher 2019

Video Transcript

[Audio Begins] [0:00:00]

Karl Beecher: Software quality is a broad term that can mean different things. In this case, I’m talking about the extent to which software carries out its functions without doing undesirable things like crashing, being insecure, or using excessive resources. These are attributes that can be measured objectively by examining the programs dynamic behavior, like its defect-density or resource usage, all by performing a static analysis of the code to look for bad practices. Quality is one of those areas where the reputation of open source software suffers. One not uncommon perception of open source programs is that they’re crappy, and bug-ridden, and put together by amateurs. And that’s an unfair stereotype. But I also won’t deny, there are reasons why that perception exists. As ever, the truth is more complicated than the stereotype. And if you’re going to make an informed choice to move to open source software, you should thoroughly understand quality in the open source world.

As the previous segment explained, open source development is usually highly transparent. The code tends to be available in pretty much all stages. Even if it exists in an early, rough state. Bleeding edge alpha versions are available to people who are bound to play with an exciting new feature, while it’s being read, it’s probably very unstable. Beta versions are there for people who want to see trial and imminent new version of the software. This all stands in contrast to the typical proprietary process where the program is only released to the outside world once it’s fully developed and gone through extensive rounds of testing. The wider public is rarely allowed to see the alpha and beta versions. So in the case of open source software, it’s true that early version, low quality code readily sees the light of day.

However, there’s also another difference between open source software and proprietary software, and it’s one that increases open source quality. The inspection and testing audience is potentially much wider. Because the programs and the code are open to anyone, open source programs can be subject to much greater peer review, and that results in inspection of code by more people who might catch potential errors or insecurities missed by the authors, a larger pool of developers who can contribute to debugging and fixing problems, and being used by wider and more diverse audience which stretches the program in more and unanticipated ways. What’s more the quality of open source software is more transparent. Those who have the required skill can do things like perform code analysis, run the automated tests, and debug the code firsthand. If you don’t have those skills, many projects post the results of their own analyses and test runs online for all to see. What’s more, public test trackers are allowed to view the currently known bugs in the system and their current status.

Does this mean that open source software can achieve a higher level of quality than proprietary software? Well, many studies into this question have been performed by bodies in industry and academia, and the results are mixed. There is little evidence to suggest that either type yields higher quality software than the other in general. However, evidence shows that the best examples of open source software are a very high quality indeed, certainly above the average quality of proprietary software.

So in summary, moving to open source software doesn’t mean having to compromise on quality. By being choosy and careful to avoid the immature, low quality stuff on offer, you can have software that’s at least as good as what proprietary software can offer. Plus, if transparency is important for your quality concerns, there’s simply no contest.

In the next segment, we’ll look at user-friendliness.

[0:03:56] [Audio Ends]