DRY madness in programming

I am a developer. Like most programmers, I try to follow the mantra “Be lazy, don’t write code that already has been written”. I preach this general truth to anyone who wants to hear it, and even more to those who don’t want to.

If you are anything like most programmers I know, this notion of copy-with-pride is nothing new. Yet, I can’t help wondering: Why are there still developers who work with proprietary software? Surely, the biggest issue with proprietary software affecting us, developers, on a daily basis is that we see all these tools but can’t reuse any of its building blocks.


To me, that is annoying. I’ve worked with Microsoft’s Visual Studio. Some of the features I found most helpful, others I couldn’t care less about. I’ve also worked with QtCreator, and really fell in love with the GUI wrapped around gdb, but found the project management tools lacking in some aspects, and the editor itself would be even better if I could sprinkle it with some of the intellisense goodness.

From a developers standpoint

If you’re an open-source afficionado, like me, you’d go looking for plugins, extensions or custom builds that have been written before. And like me, you’d find that there are some awful, and some great tools out there. Some of them were clearly inspired by Visual Studio.
And that’s the problem: they’re copies, striving to be called clones of a piece of software that has been written before.
The people who wrote them are great developers, but they are wasting time copying something that one company refuses to share with programmers across the globe. For us, code-geeks, this means we’ll have to spend time happily hacking away, writing something similar. Nothing wrong with that: it’s a great learning experience, and it’s fun to do.

From a distance

But let’s look at things from a distance: All over the world, companies are paying developers to write software that competes with existing software. In order to remain competitive, the source is a close guarded secret, and only a handful of people are granted the right to edit it.
Meanwhile, some other company is spending money in research and development to implement similar features in its products. the same work is being done over and over again!

All of this labour isn’t free, so naturally, the software can’t be given away: it’s for sale, or you have to live with in-app adds that more often than not, have access to your browser history, or some other details about you.
Worst case scenario: you can use the software, free of charge, but in exchange, you are forced to grant the company that distributed the software access to your work (see my post “trapped in heaven” for an example of this).

People often say that the academic world is an odd place, full of back-stabbing hypocrites. Well, I put it to them that the same holds true for the software industry. The same code is written time and time again, simply because companies don’t see the immediate value in working together. Collaborating on something, to get the job done in a fraction of the time, at a fraction of the cost.

They did it to themselves

I’ve tried to explain all this to people who are not in the faintest interested in IT, let alone the software industry. They all seemed to agree with me, they all agreed (so far). After I explain this, the inevitable question is: “What are you going to to about it?” or “What can you do?”.
When I tell them that the answer is open-sourcing software, an overwhelming majority of them stare at me in disbelief. They call me naive, or claim they wouldn’t trust software that was made by a bunch of amateurs.

Basically, the response is what the software giants said about Linux when it first made it big. Steve Balmer was quoted saying “Linux is like communism”. That scared a lot of people of. Especially the people who didn’t really have the kind of money to buy all of Microsoft’s software.
The image of a 16 year old amateur contributing code to the Linux kernel, and seeing his untested, un-reviewed code being released moments later couldn’t be further from the truth. If you know how the release-cycles work, and how git works, you know that.

It is obvious that none of those arguments don’t hold water: Open-source is as old as computing. If I ask them what computers and/or phones they use, I immediately tell them they are using open-source spawned systems: Linux is in almost every home, if not on the smartphones, tablets or computers, it’s on the routers, televisions, NAS’s or other equipment.
Apple is, at heart, a modified version of the BSD Unix system. And of course, Microsoft wasn’t always run by Steve Balmer, so it’s safe to say their developers did some copy-with-pride work of their own, too.
If people need even more convincing: just ask them how much of the internet is running on open-source software. If they don’t know, tell them and leave it at that.

So why did they do it to themselves? If by they you mean the software companies, the answer is obvious: they spent years, and a lot of actual marketing money, convincing consumers that their proprietary software was better, safer, more reliable in every way than something a couple of amateurs put together. So for them to switch sides, and join what they have been depicting as the dark side might scare off customers.
In fact, Microsoft has begun changing on this front already: TypeScript is open source, and they collaborate closely with Suse Linux. Their corporate clients are being eased into their new strategy, I think.

If by they you mean the consumer, you’d be right, too. The consumer has spend years paying thousands of dollars for software. To admit right away that that was a mistake is not always easy. Plus: they’ve become accustomed to a system, and to change means to learn the basics again. Just like developers, users are lazy. And stubborn. And pig-headed. And sometimes have a misplaced sense of pride.
There still is this belief that, if something like Linux really is free, there either is a catch, or it’s no good. Once we’ve convinced them that it really is good, they’ll have to realize that the only catch of truly open and free software is that nobody can be sued.

If you are a programmer, you’ve probably written tools for your current employer, that you developed before, at a previous job. This is absurd, and it must stop. That time is better spent perfecting tools, creating new and stable systems, or making open-source and free software truly accessible.
If you care, even in the slightest about any of this, please, please, spread the word. Stop the madness. It’s as though the software industry is fighting a civil war, where all of the companies are sworn enemies. Developers are the soldiers, and consumers are neutral civilians. We can’t win this one, so let’s end it, and work on a project that is worth while together.

 

Yours truly, someone who probably sounds like a hippie – Elias

PS: Death to all hippies.
— Eric Cartman

Advertisements
This entry was posted in Free software, Linux, opinion and tagged , , , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s