On 2 Dec 2017 at 23:45, Mary-Anne Wolf wrote: > This > https://www.designnews.com/content/7-reasons-open-source-software-should-be-avoided/100858102757881 > says, "As much potential as open source software can provide, there > are several reasons why embedded software developers should avoid it > like the plague." > > > You would not be surprised that the reasons generally do not impress > me. Somebody who can express it better than I do needs to > respond. _Let us dissect his arguments, point-by-point, shall we?_ * Reason #1 – Lacks a traceable software development life cycle Incorrect – free software can actually /provide/ a traceable software development life cycle. Anyone who uses a [version control system][0] (VCS) knows this to be extremely common among free software projects. [0]: https://en.wikipedia.org/wiki/Version_control_system Direct quote about a VCS from Wikipedia: Revision control allows for the ability to revert a document to a previous revision, which is critical for allowing editors to *track* each other's edits, correct mistakes, and defend against vandalism and spamming. The root word of *traceable* is trace, which is a synonym of the word *track*, hence VCS allows editors to trace/track each other's edits. Yes, free software does not *have* to be version controlled; however, it is the norm, and it is wrong to assume that ALL free programs are developed without any form of version control. _Reason #1_ is a lie! * Reason #2 – Designed for functionality[,] not robustness This is a half-truth (lie) based on assumptions, and the author does not provide any real-world examples––although he likes to say "real-world"–– that prove his point. Phrases like /is often written functionally/; /generally not robust/; /expects that a wrench will never be thrown/; /rarely the case/; and /can find/ (not *will* find), only prove that this author is assuming that free software is not designed for robustness. There are thousands of free software projects online, and he assumes that they are not robust; otherwise, he should have said that *some* free software is not robust–– this would've been more believable. The last sentence of his second reason (direct quote) is true for all software projects, and not just free software. He does not say this, of course, and by omitting this truth–– he lies: Developers will find themselves having to dig through unknown terrain trying to figure out how best to improve or handle errors that weren’t expected by the original developers. _Reason #2_ is a lie! * Reason #3 – Accidentally exposing confidential intellectual property The term [intellectual property][1] is a misleading term designed to cause confusion. Anyone who uses a free software license uses it for the explicit reason to publish/expose their software/information. Free Software licenses require users to share software/knowledge, hence it is not accidental–– it is *deliberate* (free licenses make this obvious). [1]: http://www.gnu.org/philosophy/words-to-avoid.html#IntellectualProperty Richard Stallman has written extensively about this [confusing term][1], and you can read those essays via this link (4 essays as of now): https://www.gnu.org/cgi-bin/estseek.cgi?phrase=intellectual+property+%21+diff&attr0=%40title+ISTRINC+Intellectual+Property&attr1=&attr2=&order=&perpage=10&clip=9&navi=1 _Reason #3_ is a lie! * Reason #4 – Lacking automated or manual tests Notice how he did not say "Completely Lacking." Notice also how he has looked at Python projects, but has not mentioned whether he has looked at other types of projects. Once again, no specific examples of which tests the free software community is actually missing. No references to mailing lists or forums where he has asked for such tests have been identified. How can anyone agree with such a statement without proof? More assumptions and no evidence... _Reason #4_ is *evidently* a lie! * Reason #5 – Poor documentation or documentation that is lacking completely (he said "completely"–– I WILL debunk this) Has this author ever heard of a [man page][2] (not related to men, `man' is short for *manual*) before? How about the [info reader][3]? [2]: https://en.wikipedia.org/wiki/Man_page [3]: https://en.wikipedia.org/wiki/Info_%28Unix%29 One of the *main* reasons to use free software is *because* it is so well documented. I have yet to find any software in my GNU/Linux distro that does not come with documentation. Richard Stallman once complained about [a lack of free documentation for free software][4]... this was about _[10 years ago][5]_ and is no longer true! [4]: https://www.gnu.org/philosophy/free-doc.html [5]: https://web.archive.org/web/19990224050619/https://www.gnu.org/philosophy/free-doc.html Now for my strongest point! Even if free software has no manuals which document it's use, and not even a command-line "help" option, I dare say: You can *still* learn how the software works, even without these! Some of you must be wondering how? _Here's how:_ It's free software, and you can access the source code! Has Jacob Beningo never heard of a [source code comment][6] before? Yes, it is possible to learn how software works––with or without source code comments–– and you can even generate documentation from said comments. This type of documentation, by the way, can ONLY be accessed from free software! [6]: https://en.wikipedia.org/wiki/Comment_(computer_programming) Not only is this the norm for free software, but for all GNU programs... it is [standard][7]. [7]: https://www.gnu.org/prep/standards/html_node/Comments.html _Reason #5_ is a lie! * Reason #6 – Real-time support is lacking No proof is provided here. No mailing lists have been identified where he has *personally* asked for support and received none. No references are made to any forums, IRC channels, or even wiki pages, where he has posted or published a request for support. Every (and I mean *every*) time I have asked for support for free software that is still actively maintained (some free software is [abandonware][8]), I always got it. [8]: https://en.wikipedia.org/wiki/Abandonware Anyone ever heard of the phrase: "The proof of the pudding is in the eating!" A similar phrase can be said: "The proof of a lack of support is in the requesting of said support." No requests; no support–– common sense, folks. He has omitted requests for support that he "supposedly" made, hence _Reason #6_ is also a lie (omission of requests)! * Reason #7 – Integration is never as easy as it seems Perhaps the author (with his constant assumptions) once again assumed that integration would be easy, but did not do his research about the process ahead of time. With a [catalog][9] of so many free software programs to solve any given task, I usually do my research ahead of time to determine which free program would be best to use to solve my problems. Perhaps the author went with the first free program he found and just used it without research, and without looking at other free alternatives. [9]: https://directory.fsf.org/wiki/Main_Page Once again, we won't know for sure until he explains. But can we expect an assumer who commonly omits information to tell the truth? In case it isn't obvious by now... _Reason #7_ is a lie! * (Jacob Beningo's) Conclusions By no means am I against open source software. It’s been extremely helpful and beneficial in certain circumstances. It’s important though not to just use software because it’s free and open source. Developers need to recognize their requirements, needs, and the robustness level that they require for their product and appropriately develop or source software that meets those needs rather than blindly selecting software because it’s “free.” ** My conclusions His (Jacob Beningo's) conclusions reveal him as a hypocrite. He says he is not /against open source software/ or free as in freedom (faif) software, but then states: "It’s important though not to just use software because it’s free." I––for one–– ONLY use software *when* it is free. He also states that "Developers need to recognize ... rather than blindly selecting software because it’s “free.” Apparently, I––as well as millions of others–– am/are blind and do NOT recognize. What is this guy all about, anyway? Let's take a direct excerpt from his article that describes him: Jacob Beningo is an embedded software consultant who currently works with clients in more than a dozen countries to dramatically transform their businesses by improving product quality, cost and time to market. This man is focused on improving product quality, cost and time to market–– he did not list *freedom* as a priority. This description of himself already tells us where his loyalty lies–– NOT with the community, but rather for businesses (proprietary–– very scary). Are you blind for choosing [software freedom][7]? Does anyone agree or disagree with his nonsense? I certainly do NOT agree! [7]: https://copyleft.org/guide/comprehensive-gpl-guidech2.html Truthfully -- Michael Pagan (pegzmasta) GPG Key ID: B942 AD12 82B1 6D14 27A0 86AE 119E 451E 71B4 6D72