Ben Cotton is wrong about Free Software

Meteorologist Ben Cotton recently wrote an article about Free Software on opensource.com about the hidden cost of free software, but he seemed to forget that proprietary software had equal or greater cost on every line item.

We're used to hearing of software being described as "free as in
freedom" and "free as in beer." But there's another kind of "free"
that doesn't get talked about as much: "free as in puppy." This
concept is based around the idea that when someone gives you a free
puppy, that puppy isn't really free. There's a lot of work and
expenses that go into its daily care. The business term is "total
cost of ownership," or TCO, and it applies to anything, not just open
source software and puppies.

That is a reasonable statement.

So if the free puppy problem applies to everything, how is it
important to open source software specifically? There are a few ways.
First, if you're already paying for software, then you've set the
expectation that it has costs. Software that's free up front but
costs money later seems like a major imposition. Secondly, if it
happens on an organization's first open source adoption project, it
can put the organization off of adopting open source software in the
future. Lastly and counterintuitively, showing that open source
software has a cost may make it an easier "sell." If it's truly no
cost, it seems too good to be true.

Find a vendor that would sell you the Free Software.
Maybe a business from this service directory would do it. https://www.f
sf.org/resources/service

Software: Just because it's open source doesn't necessarily mean it's
gratis.

Compare the costs of the most expensive proprietary software and the
most expensive free software you can buy. The most expensive Free
software I recall seeing was HyperRogue for 10 USD, but the most
expensive proprietary software you can buy comes for hundreds of thousands
of USD.

Hardware: Consider the requirements of the software. If you don't
have the hardware that (this could be server hardware or client
hardware) you need to use the software, you'll need to buy it.

All software runs on hardware, deal with it.

At least with free software you have the right to patch it so it runs
better. Free software is likely programmed better because few
developers want to release code they think is bad. How many times have
you heard the excuse, "I don't want to release my code as open source
until the source code is cleaned up". Yes they do use the term open
source instead of Free Software.

Training: Software is rarely completely intuitive. The choice is to
get training or figure it out on your own.

I see a service directory right here. https://www.fsf.org/resources/ser
vice

The think is, a lot of people don't want to buy service for their
software because they are used to buying apps that come with service or
insurance that comes with service.

Numbers on how effective the service directory listing is would be
nice.

Implementation Getting all of the pieces in the same room is only the
start. Now, it's time to put the puzzle together.

Free Software is easier to integrate because it almost always follows
IETF standards because there is no reason not to follow them. With
proprietary software they are encouraged to protect their secrets by
ignoring the tried and true standards.

I even had someone ask me about implementing their own encryption. I
told them it was a bad idea because we weren't as good mathematicians
as the people who wrote GNUTLS or OpenSSL, and they still needed
patched for all kinds of errors because the domain is very hard. It is
worth it for everybody to pay for development of those libraries since
they are used so often. At the very least we likely know there is a
problem when everyone else does.

Installation and configuration: At a minimum this will take some
staff time. If it's a big project, you may need to pay a systems
integrator or some other vendor to do this.

That is true for all software with defaults you don't like.

Data import: If you're replacing an existing system, there is data to
move into a new home. In a happy world where everything complies with
the same standard, this is not a problem. In many cases, though, it
may be necessary to write some scripts to extract and reload data.

That is much easier to do if you are running software that the
developers had no intensive to deviate off the standards, such as free
software.

Interfaces with other systems: Speaking of writing scripts, does this
software tie in nicely with other software you use (for example, your
directory service or your payroll software)?

This is the second valid point. Free Software would be less likely to
have interfaces directly to a proprietary system unless the system was
using an IETF standardized protocol. There is little intensive for
proprietary software sellers to risk people having an easy way out.

Customization: If the software doesn't meet all of your needs out of
the box, it may need to be customized. You can do that, but it still
requires effort and maybe some materials.

That is a point in favor of Free Software because you always have the
right to customize it yourself or with any employee, contractor, or
vendor on your behalf.

Business changes: This new software will probably change how your
organization does something—hopefully for the better. However, the
shift isn't free. For example, productivity may dip initially as
staff get used to the new software.

That is aways true. I guess the point is some businesses bank on having
other businesses train people on their own internal business
processes. The notion is asinine. Only your business has your business
process, you will have to dedicate resources to train everyone on your
business. Your best best would to make it as simple as possible while
getting the tasks accomplished.

More training: What, did you think we were done with this? Over time,
new people will probably join your organization and they will also
need to learn how to use the software, or a new release will come out
that adds additional functionality.

It depends on what it is. If the software is affordable, and most Free
Software is, employees would have more chances to familiarize
themselves with it at home for their own needs.

Maintenance:

Subscription: Some software provides updates via a paid

subscription.
Patches: Depending on the nature of the software, there may be
some effort in applying patches. This includes both testing and
deployment.
Development: Did you make any customizations yourself? Now you
have to maintain those forever.

That is all software. With free software you can get your development
integrated upstream so you can save on maintenance. With proprietary
software, you are already breaking the rules so you will have to hide
your development.

Support: Someone has to fix it when it goes wrong, and whether that's
a vendor or your own team, there's a real cost.

That is all software.

Good citizenship: This one isn't a requirement, but if you're using
open source software, it would be nice if you gave back somehow. This
might be code contributions, providing support on the mailing list,
sponsoring the annual conference, etc.

You said it yourself Ben, it isn't a requirement.

Business benefits: Okay, so this isn't a cost, but it can offset some
of the costs. What does using this software mean for your
organization? If it enables you to manufacture widgets with 25% less
waste, then that's valuable. To provide another example, maybe it
helps you increase repeat contributions to your nonprofit by 30%.

It is a negative cost, also known as a gain.

Even with a list like this, it takes a lot of imagination to come up
with all of the costs. Getting the values right requires some
experience and a lot of good guessing, but just going through the
process helps make it more clear. Much like with a puppy, if you know
what you're getting yourself into up front, it can be a rewarding
experience.

The problem Ben, is a WUMBO amount of bad guessing. Programming could
use a lot more science form the development and the administration side
to keep wild mass guessing like this article at bay. It is not that
guessing is bad, but there is no reason to guess things when it doesn't
take that much time and energy to know them instead. Building large
expensive things like information systems on guesses could make you
waste a lot of time and or lose a lot of money, if not worse.

---

Links:
https://opensource.com/article/17/2/hidden-costs-free-software
http://www.roguetemple.com/z/hyper/
https://www.fsf.org/resources/service
https://www.gnu.org/philosophy/free-sw.en.html