You are here

Emulating proprietary software - should we do it?

In the development of free software, should we allow ourselves to emulate proprietary software or should we strive to be better and unique? Is it bad that a lot of our software does emulate pre-existing proprietary software? Do we look like we are uncreative? Does it matter? Or is a good thing to emulate proprietary software so that there are free software alternatives and so that people have a choice? How do you feel about this issue? To emulate or not to emulate... that is the question.

On the one hand, emulating the creations of the proprietary world puts you in a constant position of "chasing taillights", so it's not a good general strategy.

On the other hand, there are some cases where a particular application is so widely appreciated that it is worth it to accomodate the market.

Of course, the prescriptive ("should") approach to this topic suggests a misapprehension of how free software generally gets created. By and large, software gets written because someone with the will to have it and the ability to create it decides to do so. We should never stand in the way of that.

So if we are questioning whether "we" should emulate proprietary software, we probably should examine who the "we" is, first. If 'we' is a group of people with a strategic need for a piece of software that can only be found in a proprietary form, then the answer's probably "yes 'we' should". Hence the FSF's list of critical software to write.

Of course, the primary desires should be to:

Fill application niches that are wanted, but unfilled, and

Support file formats and interchange standards that are already in use

which doesn't necessarily mean copying an application exactly. In fact, you can often do a better job by starting from scratch, and considering the needs of the user -- proprietary designs don't always do a good job of that.

So, in the end, proprietary apps should probably just be a part of a balanced, low-budget marketing assessment of what the users in your community need.

It also has to be appreciated that the core market for free software is not the same as the one for proprietary software. There are likely to be some different needs, and filling those needs is a good way to differentiate the free software offering (to use proprietary marketing terminology, of course). For example, free software users are much more likely to be concerned about producing works in open formats themselves, and to accomodating collaborative activities.

That's why when I wrote about free software CAD needs, I emphasized the need for a collaborative CAD system which could allow people to work over the internet on engineering projects. A simple copy of AutoCAD wouldn't provide that.

IMO, FOSS programmers at big projects (not the fringe ones at sf.net for example), have better GUI ideas and better Usability sense than the dominant proprietary programmers or their products.

It is inherent in the FOSS coder's thinking style: My product will be new and different. That leads us to the bigger well-known problem of "too much choice" in the FOSS world.

Nowadays, most M$ products are roughly copies of FOSS or free(Java, VJ++/C#) ideas or layouts(Vista).

However, we dont go filing patents and they do. We have no $$$$$$$'s and they do. So, for example, they sent XPde a legal notice which shut the project officially.

OTOH,
FOSS realizes that the layman alays wants *complete* UI compatibility. And The developer ecosystem wants maximum API-compatibility. So, what do you do to make your cool new FOSS program acceptable to the layman?

Firefox is a tremendous example of how things went right - yet it's market share is just 10% as of today, May 2007.

The layman also accepts, without a single protest, anything that the "latest version of XYZ" if it is supported by enough ads and hype. In his brain, the hype simply kills the fact that he is actually working at learning a new interface.

By contrast, look at how FOSS programs are introduced to the new user:

Timn00b: Hi all, i wanna know a cool foss app for zipping multiple files maybe using a dos prompt
JimHacker: http://www.7-zip.org
JimHacker: it also has a better compression ratio format called 7z. Check it out

See the difference?

It does not come and hit him the face ten times a day. It is not the thing that will deliver him from his file compresion woes.

And where is the all-important point that says that 7-zip does not show a (moving) "OK/I Accept" button and a guilt-count (no. of archives opened so far) nag screen like Winzip does.

It's acutally a huge nuisance removed, but it is not even marketed at the minimum information level.

That's why and that's where FOSS adoption fails.

OpenOffice is not so "cool" because it appears slow and the GUI widgets don't have the traditional win32 single-pixel finish at the edges.
Think again on this one. - it's that ONE PIXEL MARGIN that makes a difference - I've heard so many say - "Microsoft products look so cool and sleek". So there you are.

Another problem IMO with FOSS is that things are structured logically, for thinking users, unlike the monopolist/leading programs - those are configured for simple, non-thinking, minimum-use laymen. Structured is for logical minds - clearly not for laymen - they often just need teh one thing to be done - and configuration of the program is mountain-climbing for them. Unlike for FOSS guys who love the act of tweaking the system.

I can't recall where, but a very experienced programmer who has lived for a long time in both worlds, noted at a forum that Windows and Linux are for different people. There should not be competition, but co-existence.

That IMO, is the crux.

The problem start when M$ wants to rob Linux's share. Do we hate Apple so much as we hate M$. Apple is far worse, at least from my distance, at allowing people to do new things with their products. But, they don't forcibly pull users away from other markets. They stay put, every now and then trying for a small increment in the user base - yes, now they're trying to get into people's minds via other means - like music players and stuff - but essentially within limits.

Then, there is the patent and litigation issue for UIs and methods.
So, I personally think FOSS should keep a clean room approach. FOSS and GNU/Linux are never going to dominate. And they should not as well - because if we do that, what different are we from M$?

At the same time, if M$ tries suing and stuff, we should also end up with millions in victorious suits for *their having copied* from FOSS programs. That's a really fair situation. That also means that they have to sit and think new things as well.

I've heard of management practices like making two fully capable teams work on the same product and they compete with each other and the losing team's code is just thrown or shelved. That is a colossal waste of everyone's money. And users bear the cost. Surely, their coders with prestigious academic backgrounds know better than copying.

In such a situation therefore, case-by-case seems to be the best approach.

Look, we've already got the geeks on our side. So, who do we have left to convert? The non-geeks. Would they be more likely to use something that looks like something they are familiar with, or something they aren't? I know my parents would never have used OpenOffice.org if it looked different from Microsoft Office. In fact, they were more impressed than upset that it looked so similar to Microsoft Office.

Alienating people doesn't help bring them to your side. We should try to make free software as comfortable to the end user as possible.

Actually, Firefox (along with the entire Mozilla fleet) is a perfect example of filling application niches without emulating the proprietary competition. The only thing that you can say that Firefox has "emulated" about IE is that it focuses exclusively on web browsing, rather than a full suite of internet activities as does the full Mozilla package.

For an emulator, perfection is achieved by looking exactly like the emulated package, not just by accomplishing the same tasks. And that's why an emulator is doomed to always be "chasing taillights" -- you've defined success to be somebody else's work, so unless you are copying them perfectly, you're behind. And the most you can ever achieve on this scale is to be "as good as" the emulated package (and for an actively developed package, you are unlikely even to achieve this level of success).

Firefox, on the other hand, strives to be better than IE in the same application niche, dealing with the same types of data formats, not "the same as" IE. And that's where free software apps need to be setting their sights, IMHO.

In general, I agree with Terry, above. I'd just add that, when we're beginning to cover a particular need, replicating existing programs, whether proprietary or Free, is a reasonable place to start. But we shouldn't be beholden to the particular design or implementation of the software we're emulating (though we shouldn't throw out good ideas whatever their source).

Our particular advantage is that we can, collectively, write software _faster_ and more effectively than most proprietary vendors (not that we always do); so, while we may spend some time "chasing taillights", we can pull up even with them and begin to innovate ourselves (and we can innovate in the meantime, of course). I think we're beginning to see that happen on a large scale, now, and it's terribly exciting.

We should emulate the good and rewrite the bad. We should innovate beyond the proprietary offerings. We certainly shouldn't let all those R&D dollars (which consumers pay for) go to waste. Copy. Stand on the shoulders of giants. Chase tail lights when they are there to chase AND (only) if you don't know what direction to take OR if it is the right direction to go. Then, when they are pulled over for a break, over-take. Or, if they appear to be going in the wrong direction we should go our own way.

- If proprietary sw is so widespread and popular then emulation should be done to ease ppl who want to make a "switch".

- Instead of letting proprietary sw guide our devp, y not develop something better maybe using a different approach and beat them at their own game by providing better alternatives to *proprietary sw*. for once, they will start emulating us!