Slashdot Mirror
Shirky: Given Enough Eyeballs, Are Features Shallow?
cshirky writes "A persistent criticism of open source is that it is more about copying features than creating new ones. While this criticism is overblown, the literature of open source is richer on the subject of debugging than design. I've written an article about Ben Hammersley's LazyWeb.org, wondering whether open source methods plus RSS distribution can do for feature requests what open source already does for bug fixes, namely parallelize the problem in ways not available to closed source development methods."
To right it's about copying features then creating new stuff.
Why?
Because access to the source (so we can tweak somewhat) is all thats missing with most proprietary software.
We don't have new needs, except the need for source, the freedom Richard Stallman talks about.
Thats why.
Sam
blog.sam.liddicott.com
I've been thinking about this for a while. One of the things that is so powerful about Open Source is that it pools the abilities of so many people. Unfortunately, the mechanisms currently in place in the Open Source world are great for pooling the skills, observations and ideas of programmers and geeks, but they're not good at all at pooling them from end users.
What i'd like to see is a kind of buzilla application completely focused on feedback from end-users. Somewhere where end users could make observations about OSS applications, and perhaps other users could vote or comment on them.
I brought a digital camera the other day. Before buying it, I could go to several web sites (for instance, amazon and cnet) and see lots of comments from other people who had used it. It was really useful to me, but of course could also be of use to the manufacturers themselves to get raw comments from end users. Open source software needs something like this so that developers can see first had what people like and dislike about their software.
I really can't understand why people say that free software which copies established UIs is a "bad thing", like a flaw or failure or something.
:) )
The Net, Linux/BSD and the wealth of tools all provide hackers with the opportunity to code endlessly, but one thing we can't do is interface research.
So it's the best of both worlds: we can make use of all the money and time put in by Apple, MS etc. into human/computer interface research, yet capitalise on the power of open source to deliver stable, versatile software.
(Of course, Apple isn't too happy with direct copies of their UI, and I could've worded this better, but only woke up 15 minutes ago
Yep. A piece of software is designed once, and then it may be debugged many times, perhaps forever...
Debugging is a (IMHO silly) way to understand how a program works, to find out were and how it fails or where and how it may be improved. That and the possibility to reuse pieces of code, is all that opensource is about. This gives the public - more specific developers like some of us - the power to fix problems and add features right away.
However I do not see how this idea of communication about features will work. Assume I code some feature I have a need for. I would just submit the modified code. I will not go and see if I made some users happy. So who is going to? Assume you have need for some feature...
...
Well that's where the story ends, I guess. Or you'd have to call me and pay for it.
giel.y contains 2 shift/reduce conflicts
Frankly I'd rather use a poor design that's relatively bug free than some focus group approved design that's loaded with lots of strange quirks and inexplicable hangups. Sure, using a poor design is like learning to ride a camel backwards, but as long as the camel is consistant and gets the job done it beats the dominant camel vendor's approved "industry standard", slick, nice looking, user friendly method when the animal keeps keeling over and dumping your load.
try { do() || do_not(); } catch (JediException err) { yoda(err); }
I bought a computer to _compute_. I'm a developer and a user. Back in my day, all home computers came with built-in development environments. Now, a WinXP-PC is essentially a TV-set - the whole OS is structured to discourage exploration, and to encourage users to remain dumb and leave development to "professionals".
I use Linux because it represents a progression of the amatuer computing environment. I would take a dedicated amatuer over a professional any day in computing. I don't care about assholes who think that computers are "just tools". To me, a computer is both a means to an end and an end in itself.
I am authors of a few apps, some popular, some less. According to my experience, your rate of bug reports is quite average. There simply is little feedback from users, and the given enough eyeballs, all bugs are shallow really only applies to the very popular applications. I would guess that anything below popularity rank 500-1000 on freshmeat has too little feedback for efficient bug hunting. As for features, I would say the rate of requests is similar to that for bug reports.
They sit there, with their lightweight psychology, graphics design, philosophy, women's studies, physical education, etc degrees, and contemplate and measure cost/benefits of how the software should work. When appropriate, they poll users. They perform usability tests on actual users. They monitor how actual users use existing versions of the software in order to both spot common errors and figure out exactly what features are actually being used. They document what they do. They read books and articles on nominally the flimsiest of things, like "the psychological implications of color choice in menu design." Their feature requests sometimes border on the really difficult to implement, and sometimes quite simple.
Theirs is a full-time job. Even, if in your arrogance, you don't believe that it takes particular skill, at least grant them that it takes time to go and set up actual usability testing sessions and so forth.
The implication is that PROGRAMMERS DON'T DO DESIGN (at least, interface / features design). Or, at least, anything a programmer might do is reviewed and analyzed.
Needless to say, this is totally different than in oss/linux, where programers are really the only actors in the whole software development cycle. "design" is accomplished largely by copying other products, whcih inevitably leads to a lack of appreciation for the subtleties that make up for good interface and usability design.
Gimp and Xfig - my two favorite whipping boys, are examples number one and two of programs that nominally have the features, but in practice are painful to use compared to their closed-source equivalents (Photoshop and Visio).
The problem is as well is that there is no plausible way to get designers and similar 'soft skill' people into the OSS cycle today:
- culturally, the OSS 3l337 reject anybody without super-skills. don't even pretend that this isnt true.
- Technically, there are no mechanisms in place for this. CVS is about code. The development model is essentially about continuous 'patching' of the software rather than grand rearchitecting, which design considerations often require.
- economically, there's little hope of getting quality designers involved. Programmers barely get recognition in OSS (blowing to hell ESR's naive theories, btw). Who would care who designed what? How do you get street cred as a designer? I mean, it could happen, but it would take a pretty big mental shift.
Design = customer focus. OSS too often has this not. Profit drive causes customer focus. Alas.I certainly hope that aircraft or automobiles I am on are not put together like that. What OpenSource _CAN_ do is provide the solutions in parts that can be then put together like the end user wants (or end developer). Instead of saying, "Our tool uses GTK for its front end" try saying "We provide with our app an optional GTK GUI front end as an example" and actually design the system from the beginning to allow for a more abstracted method of output and input. If I want HTML as output, no problem... perhaps GTK is not a viable solution for me, then I will go with X-widgets of some sort I like.
Sometimes this is rather difficult I realize, but if I have to rewrite the core app then I will most likely start from scratch. If however, I want a good app to build around and on top of then I will need to be able to use it much like a library or at the very least a single separate blackbox device that I in turn define the input and output methods and formats (within reasonable limits).
I've done as you suggest multiple times to no avail. The request is either not "sexy" enough or somehow not important enough. For instance, THE reason that openoffice/staroffice will NOT replace M$ Word or Wordperfect in academia/science is a total lack of ability to handle references and citations. Word and Wordperfect do this beautifully and professionally (good enough for submission and publication in professional journals) through their designed ability to work well with 3rd party apps like EndNote. I have made the request/statement to Stardivision, to Sun when they took it over (twice!), and to Openoffice.org several times over the years to no avail. Thus, these packages are mere toys for use by people who either plagerize (failing to cite references) or people who don't do serious research/writing and thus don't need to give attribution or support their ideas/claims. These tools are for letter writers and memo passers, not college students or researchers or professors.
I have also asked several groups to consider moving away from the should-be-extinct Motif interface to a modern, user friendly, SYSTEM friendly widget set (QT or Gtk). Motif IS UGLY, CLUNKY, AND NEEDS TO DIE. It has NO respect for screen size, insisting of shooting beyond your window borders such that you lose the ability (in some cases) of manipulating buttons and menus. If something happens such that you move the app interface beyond your window borders, you're screwed because it will happily reside in no mans land beyond the reach or your mouse cursor. Simple requests like this (FRIENDLY and REASONED requests, not rants) are ignored or quickly blown off. Why? Because developers don't understand nor care about endusers and app usability. As long as THEY can use the app just fine, tough shit for anyone else. My way or the highway.
This is the area that OSS cannot compete with commercial. In commercial software development, it REALLY DOES MATTER what the interface looks like (psychology is important) and principles of interface design are known and adhered to. They don't just willy-nilly toss together an interface and call it good enough.
In Bushworld, they struggle to keep church and state separate in Iraq as they increasingly merge the two in America.
Programming should be a subject taught to everyone the way reading and math are. Obviously not everyone is going to choose that as a career but they'll be able to do minor programming to solve their own needs. I'm so often asked to write little programs that anyone could whip out in a few hours time that really it irks me that they don't think they can do it simply because they misunderstand what programming is.
Obviously not everyone needs to know C++ but Python/wxPython would be a good start especially if development tools can make it as easy as VB without the limitations of VB. PHP is also an excellent language to teach non-professional programmers because HTML makes UI's so easy to develop. Logo is good but I'm not sure how standardized it is.
The average Joe having a basic understanding of programming combined with opensource is really where things are going to explode in productivity. Thousands of simple single-purpose programs will flood the Net and the more professional level of programmers will get better feedback from their users.
At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
We ALSO need to maintain the Unix philosphy of SMALL TOOLS THAT DO ONE THING WELL that you can combine - and perhaps develop a GUI paradigm for that, not throw the kitchen sink into every package.
Note prior to my comment - I am an "end user" (for the most part) not a developer. As such my comment may be ignorant about how things are working behind the scenes, whats possible with the existing techniques (but not actually showing up in the software...) etc. etc. etc. Anyway, on with the comment...
Amen! It seems once you start using a GUI there is a tendancy to build monolithic programs that do *everything* themselves even though all the other programs also do many of those same things. But I don't see why this has to be that way. It seems you could have some standards that organise and identify independent components (plug-ins?) by function. Perhpas something like mime types that has both a general and specific classification - like "text/spelling" for a spell checker/dictionary or "text/search" for a gui for grep etc.) Application developers would figure out which classes of plug-ins make sense to load into their program and where the particular classes and sub-classes show up in their gui (rather than putting them all under "services" like OS X).
From an end-users perspective it is *bad* that there are slightly different tools with slightly different capablities doing much the same thing from app to app to app. Every word processor or text editor needs/has a "search" function - why don't they all use the same one implemented in the same way and why can't that way be determined by me, the user, by installing the search utility of my choice that would be used by every program that needs one. For that matter lots of applications need text-editting (or word-processing, or image editing etc.) themselves - why don't they all use the same full featured application as a component rather than having their own lame version of that functionality or forcing me to launch another application; do what I need to do; copy or save the result and import/paste it into where I need it. If you really did this right there would even really be distinct "apps" you'd open a document and the components for any type(s) of data in that doc would load so you could do whatever needed to be done with whatever was in the document.
It never became a reality (at least for the end user) but it seems that Apple was working on something like this with OpenDoc.
OSS is, we all know, is largely programed by geeks to 'scratch an itch'. Geeks don't itch for "features", they itch for functions. Tools.
A "feature" is something that was invented by the software *industry*, and has little to do with actual functionality. The purpose of a feature is to cater to *customer* demand, or to drive the upgrade cycle to maintain cashflow into the company even though they havn't developed any new *functionality* in years.
As Rex Roberts noted in his book "Your Engineered House" way back in 1964, no one makes money by telling you you don't have to paint your house at all.
Geeks are, by and large, perfectly happy with vi and emacs because they *work.* They not only work, but if you *combine* them with other other tools they can do far *more* than, say, MS Word. So why would a geek spend his time programing a less *funtional* "product"?
He doesn't have to convince to buy new stuff all the time just to suck money from your pocket into his.
He also understands that *stability*, both temporally and in the computer sense is an important "feature" because it increases *funtionality.*
What has OSS come up with in terms of "innovation"?
Well, Perl, Python, Ruby. In fact, OOP itself is the result of "open source" thinking. So is the relational database. These don't have much in the way of "features" though, in the way you've been led (and yes, you've been *led*) to think of them.These are geek tools. No wonder the magazine "pundits" don't know what OSS has done. Everything it's done is under their radar even though they benifit from these geeks tools every day.
Oh, by the way, I'm an "old fart", so I'm more fully aware of one fact of the state of the art of computer software and hardware than most. Before 1980 Open Source was a fairly normal way to go about things, and in many respects the entire computer industry is built on a open source base. It was the *closing* of source in the '80's that strangled development and put it on the same plane as selling chrome on a refridgerator as a "feature".
So what has OSS done? It *created* computer science. I was there. I saw it. I know *why* RMS behaves in some of the goofey ways he does because I fully understand the *stimulus* that resulted in it.
So you want better and more "innovative" software? Ok, the first thing you have to do is drop the entire concept of *feature*. A feature is chrome, bells and whistles added as a *sales tool*. It isn't innovation and it isn't technology. They are generally trivial and completely *devoid* of technology but exist simply to get "the masses" to oooooh and ahhhh over them.
The odds of your being able to do this are slim though. You've been well trained, since birth, to think of software as "technology", and a *product*, not a tool.
Pundits are, for the most part, *paid* members of the "software industry." Their own salaries depend on, either indirectly or *directly* on pushing new features to drive sales.
It isn't even in their interest to notice true innovation and most of them wouldn't recognize it if it bit them on their proverbial asses.
Is it any wonder they might bitch about the lack of "innovation" in OSS because it hasn't come up with any spiffy new "feature" the masters who pay them can take and sell?
Software as a *tool* follows the same slow, evolutionary and *function* based development pattern that say, the hammer does.
Software as "features" follows the same development pattern that leads clothing fashions to change overnight or tailfins on cars to get bigger every year.
OSS has no incentive to make the tailfins bigger.
Thank God.
KFG
What you are describing is 1989 technology that ran on 8Mhz CPUs with 512K of RAM.
There's no good reason that a word processor with features enough for most of us can't fit into a palm pilot and not be a burden when being run by a full scale modern desktop computer.
A Pirate and a Puritan look the same on a balance sheet.
That's a good question. Probably because people don't think of it that way. There are frameworks for this in place ... first OLE, now COM, probably soon .NET(?) on Windows, Bonobo for GNOME (which is built on top of CORBA, a more generalized standard for making "requests" from "objects") ... I'm sure other platforms have other standards, I bet at least some are CORBA-based.
Why don't people do this? I dunno. I can't say that it seems like it would be bad or very difficult, as a developer. Provided you had a decent implementation of your object frameworks (CORBA, or COM, or whatever). However, I don't have any direct experience developing for these frameworks, so I can't say much.. Somebody here know COM or GNOME?