*
programming and human factors
by Jeff Atwood
*
Have you ever used those self-service checkout machines at a grocery store or supermarket?
What fascinates me about self-service checkout devices is that the store is making you do work they would normally pay their employees to do. Think about this for a minute. You're playing the role of the paying customer and the cashier employee. Under the watchful eyes of security cameras and at least one human monitor, naturally, but still. We continue to check ourselves out. Not only willingly, but enthusiastically. For that one brief moment, we're working for the supermarket at the lowest possible pay scale: none.
That's the paradox of self-checkout. But to me it's no riddle at all: nobody else in that store cares about getting Jeff Atwood checked out nearly as much as Jeff Atwood does. I always choose self-service checkout, except in extraordinary cases. The people with the most vested interest in the outcome of the checkout process are the very same people that self-checkout puts in charge: me! How could it not work? It's the perfect alignment of self-interest.
I don't mean this as a dig against supermarket employees. They're (usually) competent and friendly enough. I should know; I worked my way through high school and part of college as a Safeway checker. I tried my level best to be good at my job, and move customers through my line as quickly as possible. I'm sure I could check someone out faster than they could do it themselves. But there's only one me, and at most a half-dozen other checkers working the store, compared to the multitudes of customers. It doesn't scale.
If you combine the self-interest angle and the scaling issue, self-service checkout seems obvious, a win for everyone. But self-service is not without issues of its own:
There are certain rituals to using the self-service checkout machines. And we know that. We programmers fundamentally grok the hoops that the self-service checkout machines make customers jump through. They are, after all, devices designed by our fellow programmers. Every item has to be scanned, then carefully and individually placed in the bagging area which doubles as a scale to verify the item was moved there. One at time. In strict sequence. Repeated exactly the same every time. We live this system every day; it's completely natural for a programmer. But it isn't natural for average people. I've seen plenty of customers in front of me struggle with self-service checkout machines, puzzled by the workings of this mysterious device that seems so painfully obvious to a programmer. I get frustrated to the point that I almost want to rush over and help them myself. Which would defeat the purpose of a.. self-service device.
I was thinking about this while reading Michael Meeks' article, Measuring the true success of OpenOffice.org. He reaches some depressing conclusions about the current state of OpenOffice, a high profile open source competitor to Microsoft Office:
Crude as they are, the statistics show a picture of slow disengagement by Sun, combined with a spectacular lack of growth in the developer community. In a healthy project we would expect to see a large number of volunteer developers involved, in addition - we would expect to see a large number of peer companies contributing to the common code pool; we do not see this in OpenOffice.org. Indeed, quite the opposite. We appear to have the lowest number of active developers on OO.o since records began: 24, this contrasts negatively with Linux's recent low of 160+. Even spun in the most positive way, OpenOffice.org is at best stagnating from a development perspective.
This is troubling, because open source software development is the ultimate self-service industry. As Michael notes, the project is sadly undermining itself:
Kill the ossified, paralysed and gerrymandered political system in OpenOffice.org. Instead put the developers (all of them), and those actively contributing, into the driving seat. This in turn should help to kill the many horribly demotivating and dysfunctional process steps currently used to stop code from getting included, and should help to attract volunteers. Once they are attracted and active, listen to them without patronizing.
Indeed, once you destroy the twin intrinsic motivators of self-determination and autonomy on an open source project, I'd argue you're no better off than you were with traditional closed source software. You've created a self-service checkout machine so painful to use, so awkward to operate, that it gives the self-service concept a bad name. And that's heartbreaking, because self-service is the soul of open source:
Why is my bug not fixed? Why is the UI still so unpleasant? Why is performance still poor? Why does it consume more memory than necessary? Why is it getting slower to start? Why? Why? The answer lies with developers: Will you help us make OpenOffice.org better?
In order for open source software projects to survive, they must ensure that they present as few barriers to self-service software development as possible. And any barriers they do present must be very low -- radically low. Asking your customers to learn C++ programming to improve their Open Office experience is a pretty far cry indeed from asking them to operate a scanner and touchscreen to improve their checkout experience. And if you can't convince an audience of programmers, who are inclined to understand and love this stuff, who exactly are you expecting to convince?
So, if you're having difficulty getting software developers to participate in your open source project, I'd say the community isn't failing your project. Your project is failing the community.
When the grocery store next to the office finally put in self-serve checkout lines, one of our developers had a chat with the manager. It seems that there are levels of machines. The inexpensive ones have errors for no reason, the scales get out of calibration, and they require a lot of cashier support. The really good ones (and I don't know what the price difference was) are reliable, have a good UI, are error-tolerant, and generally much easier to work with. This store put in the really good ones, and despite shopping there several times a week, I've never had an issue with them. They let you scan ahead of the UI (I believe the UI actually stops some of the detailed hand-holding if you're fast enough), and they don't require a cashier to come unlock them if you commit the horrible sin of picking up your bag while the CC transaction finishes. I know of one person who crashed one when he scanned his loyalty card as a bar code instead of using the card reader, but that's been fixed. And the manager does his managing from the area around the machines, so when it's quiet, I've seen him spend time with some of the elderly customers, teaching them how to use the machines.
All-in-all, it's a pleasure to use them. The same can not be said of many other installations I've seen.
Isn't the community for *OpenOffice* users *not programmers*, for the most part?
Open source blather works great for *things programmers like to work on* (or have to use to make a living, and thus have a motive to make work well, for their ends).
(And none of this affects the problems of collaborative interface design by programmers. I don't think those problems *are* soluble without changing the collaborative and by programmers parts.)
Sigivald on January 23, 2009 1:49 AMI loved the idea of Linux, an alternative to the MS malevolent kingdom, until I started having to use it myself at an DOE lab while I was in college. The elitism was too stifling, any time I went on an forum to ask a question I was treated as crap. As a disclaimer, the staff at the DOE lab were very nice.
I still admit that Linux is a better product, but I cannot endure the EGO's that go with it.
I see this attitude in open source in general. Sometimes it's just better(not always there are some great open source products out there) to pay the money and be done with it.
The big problem I have with OpenOffice is not that it is a MS Office clone, but that it isn't a good enough clone. Calc, in particular, has a lot of issues relating to formatting cells in a spreadsheet, particularly in the area of borders and fill patterns. Not only does it lose formatting from imported Excel spreadsheets, it doesn't even keep its own formatting consistently under modifications to the cells. That's a problem when it loses formatting that conveys semantic information.
No, I haven't taken the time to try to file bug reports or fix the code; it's often easier to just fix the immediate problem and move on. But I should note that this is an area where it's hard to write good unit tests, since the failure is related to the appearance of the output on the screen or printed page, which are hard to sense automatically.
Dave W. on January 23, 2009 1:59 AMThe problems of Open Office development have been looked at time and again and one issue that comes up again and again is the code organization.
My understanding is that it takes a good deal of time to even start to understand the codebase.
From there, if takes a while to prove that you understand enough to be able to contribute in non-harming ways.
I thought the 3.x+ versions were focusing on breaking the code into more manageable and grokkable parts. Anybody know of the progress of these things?
Jim on January 23, 2009 2:06 AMForget to mention Excel. Thanks Dave. :)
Excel is the best office product that I have ever used!! And I've used a bunch (does anyone else remember Star?). It alone is reason for MS.
I know this has nothing to do with programming, but...
People who support self-checkout systems have no right to complain when their 16 year old son/daughter applies to 100 different stores and still can't get a job because none of them are hiring.
Just like we've alway said...computers are cheaper than humans, right? Sometimes this backfires.
Matthew Morgan on January 23, 2009 2:44 AM
Tom DeMarco goes into this in some depth in his book Slack. I can't remember the original quote (and someone has borrowed my copy and hasn't yet returned it), but it was something like this:
In a volunteer organization, the flexibility to decide how you are going to do something is the payment for doing it. If, as a manager, you take this control away, you find yourself without volunteers -- and hence doing it yourself.
first
So, if you're having difficulty getting software developers to participate in your open source project, I'd say the community isn't failing your project. Your project is failing the community.
Amen! But do you have a concrete suggestion to the OOo management?
Ben on January 23, 2009 2:58 AMAfter the Kohei story it looks like OpenOffice is doomed without an independent foundation.
http://developers.slashdot.org/comments.pl?sid=1074439cid=26248793
Had to be done - sorry Jeff! I like the comparison. As for your problems with self-checkout I find that people that would have problems with them generally steer clear. I'm assuming the same would go with OSS. If you aren't comfortable with your abilities and skills, you aren't going to contribute.
Maybe the solution (or part of a solution) would be to make the adoption barrier easier by providing tutorials on how to contribute. By providing lists of fixes that are required. By advertising which sections of code need to be created or maintained.
I'm aware of bug databases and requirements, but I'm thinking more along the lines of the following:
Required:
C++ programmer to fix bug #123 [ link to bug ] in project. Likely source code is [ here ].
Or..
Required:
Python developer to help implement X feature in Y product.
On the otherhand, providing specifications to enthusiastic developers would probably mean that person has the time to implement the feature themselves.
For instance, I probably wouldn't mind contributing to a project, but I don't know which project I'd like to help with or where to start. People say 'check out the bug databses and issue a patch'. I hear look for a bug description, download source code, look through the mountain of code, fix it, and sit on it.
My .02.
`Josh on January 23, 2009 3:07 AMCould the problem be that the people who actually want to use OpenOffice are not the people who can or want to contribute to open source projects? Programmer focused tools (Linux, Emacs, vi, etc) never seem to have trouble attracting talent.
John on January 23, 2009 3:07 AMI've always been an advocate of the 'one strong leader' philosophy myself. After that, you can have whatever levels of politics you like to delegate tasks to, to make recommendations, to answer the questions that the leader needs answering - but there must always be one single voice of ultimate authority, if you ever want to get things done.
I used to disagree with this philosophy entirely, as I suspect many readers here will, thinking that people who can't make democracy-based organisation work are the problem. What I believe now is that pretty much everyone on the planet is in that group, myself included, and very few of them realise it.
People with a chance to have a say rarely let that chance pass them by, even if they have nothing worthwhile to do with it.
Schmoo on January 23, 2009 3:12 AMI think the main problem of Open Office is, that it still feels slow, bloated and ugly. I doubt there is much they can do about it, besides rewriting large parts of the software.
xyz on January 23, 2009 3:13 AMBut there's only one me, and at most a half-dozen other checkers working the store, compared to the multitudes of customers. It doesn't scale.
Sorry, doesn't work as you want. There's still a limited number of self-service checkout devices. Sure, in some supermarkets many lines are not manned all the time, and this would be an improvement, but there's still an imbalance between customers paying and lines.
Adriano on January 23, 2009 3:15 AMHey Now Jeff,
Great comparison.
Coding Horror Fan,
Catto
The problem with Open Office is that developers don't use office.
Harry M on January 23, 2009 3:21 AMAt risk of diverting into the whys and wherefores of supermarket operation, I'd like to see more of the automated checkouts which work by having a scanner that you take round the store, scanning the items as you take them off the shelf.
This is because even in a crowded store, individual products are pretty much uncontended. There are thousands of lines in the supermarket, and maybe only a couple hundred folks in there at most. And even if I do have to wait for someone to scan their item (and there's no reason why they couldn't remove the item from the shelf, move away and *then* scan it if that shelf is popular) it will take me an extra three or four seconds at most.
The checkouts, on the other hand - there might be only a dozen or so of those. So it's not efficient to have a time-consuming process such as scanning all your items happen here. Far better to do the scanning before (when there is spare capacity for it) and reduce the checkout (which doesn't have spare capacity) down to the only the relatively fast operation of payment.
This works if we shop with the big re-usable type of shopping bag - because there's no need to unload and then bag groceries at the checkout. They already got scanned when they went in the bag. Providing the checkout system knows the weight of the bag (most automated checkout systems I've seen enforce honesty on the basis of checking the weight of your bag against the expected weight of what you said you bought) all you need is to weigh each bag on the way out to make sure it tallies.
In programming terms, this is effectively precomputing results while you have spare processing time in order to maximise throughput in a performance-critical loop. Perhaps more developers should take sabbaticals to run retail businesses. :-)
Timberwolf on January 23, 2009 3:22 AMTimberwolf, have you seen this? Related to checkout:
http://www.youtube.com/watch?v=US-GcgHL2HM
Jeff Atwood on January 23, 2009 3:25 AMSuperb comparison.
As a tech-centric person myself, i love the *idea* of self checkout, and as you do can see the nature of the design of these systems.
however, unlike you I am not so keen to immediately jump into the self check line....
In the UK, there are 3 supermarkets near me that use them. of those 3, 1 of them has them set to totally untrustworthy... the most obscene settings where if if everything doesn't measure up exactly right it spends a long time wailing at you that there's a problem somewhere. My attempt to expedite the process results in me working faster than the system can cope with, ulimately slowing the whole situation down.
In this particulat chain, I *ALWAYAS* go for te human, where they scan as fast as they possibly can....
and guess what... the chail involved is owned by... a 'mart' next to a 'wal'
Alistair on January 23, 2009 3:27 AMCould the problem be that the people who actually want to use OpenOffice are not the people who can or want to contribute to open source projects?
There are many software developers who have to express their ideas to others by creating images (draw), presentations (ie. conferences), and documents. How else are you supposed to pass documents back and forth with clients to elicit requirements and project proposals and what not. Businesses live in office software; they do e-mail, word processing, spreadsheets (to represent EVERYTHING... uhh), presentations, and that's it. Any interaction with them will be through those tools, so I don't see how there isn't any overlap between developers who can contribute to that environment.
As for the 'want' to contribute, that may be the big taker...
@timberwolf
every store near me that has those hand held scanners, gets my vote. there just aren't any in the proximity i'd like... I have to go an extra 10 miles to get to the nearest one. but they are ALWAYS faster than any scan-all-in-one-go system
I had to use on of those blasted self-checkout contraptions once. They're incredibly unintuitive, even for a young person like me! It's a pretty daunting experience too:
- You're all alone at the front of a queue; one full of impatient people.
- There is no store clerk or assistant in sight.
- If you get stuck, you're doomed!
- You can't just abandon the machine and leave the store, that's shop-lifting!
- And clearing a transaction (cancelling) couldn't be harder!
Don't get me wrong! I love the idea of self-service but the supermarkets that implement it really screw up when they assume people will know how to use it. If supermarkets are to integrate systems like this then their responsibility surpasses any monetary limits; they have the responsibility to teach the masses how to use this scary machine!
James on January 23, 2009 3:32 AMI find OO.o quite uninteresting. At the same time, I find it completely absurd MS is still allowed to make money from their office suite. Or, better put, I find it incredible that a bunch of governments or even the UN haven't teamed up to create a worldwide available free office suite. It's not like those things haven't proven themselves.
Sure, fighting hunger, bringing democracy and supporting cease-fires is important too but having a Free Software office suite would be a fairly simple and cheap way to distribute wealth and be probably a lot more effective than most of the money spent at development nowadays.
MS losing their cashcow to unfair competition? True except they're not exactly free from sin when talking 'bout unfair competition. It's the size of the cashcow that tells us how important it is for the people in the world.
Caesar Tjalbo on January 23, 2009 3:40 AMThere's only one core benefit of using a checkout. Sometimes, you find that rare exemplary staff member who can actually process and bag your items faster than you can put them on the belt.
I haven't seen this often however, but when you see it, its impressive.
Also, the self checkout gets over-popular some times, just like the 12 items or less express lane. Sometimes it can be faster to bet the odds and take the slow lane and you'll get through faster.
( Although, quantify speed of an isle by the net amount of produce to be processed, not by number of customers )
Kent on January 23, 2009 3:49 AMI think Harry M has it right - developers tend not to use office suites and therefore don't care about them. Wild horses couldn't drag me to working on something like OOo.
Russ on January 23, 2009 3:51 AMI think it's a pipe dream that something like OpenOffice can survive only on volunteer contributions. It needs an organisation to sponsor it, with money or developer time. And that organisation needs to benefit from the existence of OpenOffice - not like Sun who (IMHO) turned it open source just because they *hate* Microsoft. Candidates might be goverments who don't want to pay up for Office - China, India, are you listening?
Have a look at what Joel said about the economics of open source - many big open source projects are backed by big business, because they stand to benefit.
http://www.joelonsoftware.com/articles/StrategyLetterV.html
MarkJ on January 23, 2009 3:51 AM`Josh, your first post (well, the one right after that first) was extremely insightful. You took the words off my screen. I always hear: if you don't like it, fix it. Well... yeah, I would, but how? I have to find out how to get the code, learn to use whatever versioning system they use, learn the language the application is written in, find out where the bug is, find out how to fix the bug, fix the bug, find out how to create a patch, find out how to apply a patch, find out how to make the patch public, find out how to get rights or someone's attention to be able to merge the patch into the trunk.
Once, I've actually made a very nice code improvement but I simply couldn't find someone to merge it and I couldn't find any way to make it public. I could post it on my blog (which I don't have) for which nobody would care. I could post it to Slashdot which is full of crap and the front page material always sucks. So I finally managed to create a good patch for a very annoying bug but there was no way for me to get the community to know about it and use it. It's not the case with OOo, but it's often the case with forgotten software which isn't abandoned, because lots of people still use it, but the original authors stopped caring about. You can try to reach them by email, there is no community, even if people would want one, because there's no way for them to get in touch with each other since the main website is forgotten, etc...
Let's not forget, this is brand new code, which I've never seen before and first I have to get familiar with it, otherwise, I risk screwing up some things. The main problem is that every OSS project is brand new code to whoever tries to change it.
Good luck with OOo, you'll need it! I would help, but I'm afraid that it would take TOO long until I actually get anything done. I rather just read Slashdot, Coding horror, XKCD, TDWTF and play a game.
Tom on January 23, 2009 3:51 AMI think the reason it's hard to get developers interested in working on a project like OOo is that developers don't typcially use office software much in the first place. And when we are likely to use it, we're usually in a place where MS Office is already available and is the default.
Michael on January 23, 2009 3:55 AMIn Sweden the self service checkout generally consists of getting a hand-held scanner when you enter the store and you scan on your own good time as you walk through the store. When you get to the actual checkout there are store clerks that ring up your total and ask if you had trouble scanning any items. Every once in a while you also get a spot check where they scan all your items again. This relieves much of the stress you talk about and gets you better throughput at the checkout.
Magnus Falk on January 23, 2009 3:56 AM@xyz,
I agree that it feels 'slow, bloated and ugly'. I also don't see a way out. For instance, I use it on Mac OS. They moved mountains to make OpenOffice.org 3.0 a native Mac application (previous versions used X Windows), but it's still obviously Carbon. This is a problem which will only get worse as Cocoa leaps ahead while Carbon is deprecated. On Windows, it will have the same problem sitting next to slick new .NET applications, when it can't use .NET while staying massively cross-platform.
Apart from general shininess, there's all the modal dialogs, which are SO last century. Changing those could well require massive changes to the underlying data structures, so they can cope with updating every time you change a property.
I'd dearly like to see OpenOffice.org enter wider use. I don't want to see MSOffice die - I just want to be able to e-mail people OpenOffice.org documents and have them be readable. On my end, I don't have Microsoft Office installed, but that's only achieved through three different applications: iWork (for rapid page layout and presentations), OpenOffice.org (for medium-length text and graphics) and LaTeX (for academic writing). I can hardly recommend this to anyone who isn't a programmer!
Lesser Whark on January 23, 2009 4:03 AMI think it's slightly more subtle than developers don't use Office. Since most developers (the invisible part of the iceberg) work within enterprise situations, they're largely Windows-based and they almost certainly have at least the basic version of MS Office available to them. Say what you like, the OO apps only just match their MS equivalents at best and fall way short at worst.
It's probably fairer to say that developers don't use Office - or Open Office - much, and it's adequate for what they do use it. So there's simply no incentive, no interest no *value*, real or otherwise, to getting involved. Heck, it's not even sexy!
OO doesn't do enough for me to be able to stand using it but that's OK, I have Office Pro, which mostly has what I want and I have years of experience extending it where it doesn't. OTOH, OO has more than enough capability for the rest of my family so there's no pressure from them for additional work.
When I contribute to open source, it tends to be small tweaks (extensions and/or fixes) to small, grokkable items, such as Ruby gems (libraries) that I actually use and are small enough for me to be able to grok them.
Once OS stops being fun, then you need to be compensated in some more material way to continue working on it. Which I guess means some sort of financial model. Philanthropy is good but rare, after that being paid to work on open source requires a revenue stream to fund it. What's Sun's business model for OO? I can't imagine. And now it's stuck: no-one wants to work on it for free and its principal backer doesn't want to pay for it.
Mike Woodhouse on January 23, 2009 4:10 AMLast week I was checking myself out of Tescos and was stopped because I was purchasing a product that required authorization of age. As a programmer I knew exactly what the problem was without first having to ask the assistant. I had bought plastic cutlery. Knives.
Kent Boogaart on January 23, 2009 4:11 AM@Jeff: I don't think expecting a developer to know C++ is a major requirement. You're likely to get some more developers interested by embedding python/ruby/someotherscriptinglanguage somewhere, but the C++ community is large enough that you're not really limiting yourself by using it. Likewise for the java components in OO.org, there's a huge community there that could potentially contribute. Remember that most of kde was written in C++ and you don't see them struggling to get developers.
Just pointing out that you got this one ass-backwards: people who cannot code (in this case, in this particular language) are not the people who ever contribute code to projects. They can however contribute bug reports or (positive) critiques of the UI design for instance. Or they can develop some good example apps to show case the toplevel APIs of your work, such as the access-like features OO.org has.
In any case, consider as well that OO.org is not the only os office suite. KOffice has been around for a while and is apparently quite good. Gnumeric shares a lot of code with oocalc and abiword is a favourite of many developers. There's choice there, and putting all your eggs in one basket is a bad idea, since projects do fail and open source projects probably at about the same reason as propietary ones, if sometimes for slightly different reasons.
wds on January 23, 2009 4:32 AM...at about the same rate*, where's the preview button on this thing?
wds on January 23, 2009 4:33 AMAnd then there's the annoying way the entire thing freezes if you buy a bottle of wine until the dozy onlooker notices that he needs to press the stop being stupid; the customer looks grumpy and middle-aged button. It's fair enough that they have to abide by silly laws that require such checks, but it should allow you to continue scanning other items in parallel whilst you're waiting for Mr Dozy to notice.
James D on January 23, 2009 4:39 AM- It should be disclosed that Michael Meeks works for Novell and seems to have a personal story with SUN.
- read http://en.wikipedia.org/wiki/OpenOffice.org#Ownership
- While Meeks complains, IBM, RedFlag and Google are sponsoring, contributing and sharing.
As for me, I use Google Doc.
What fascinates me about self-service checkout devices is that the store is making you do work they would normally pay their employees to do.
-- Before they used to pay their employees to get the products using your product list. Now we are used to pick 'em for ourselves. You are not just used to it yet. That's all.
The suggestion that you're working for the store for $0 is fun to think about, but falls apart pretty easily. When you choose the self-check line, you're opting for a less service-oriented experience, but you're not working for the store anymore than you are when you choose to walk the aisles aimlessly until you find the pickles, when you could have stopped and asked an employee for help.
It seems that another lesson to take from the supermarket model is that not every customer wants the expensive full service that paid employees provide. If there are customers who would happily opt-out of such services, then the business and its customers can both win by facilitating a path that doesn't them.
When a business outright cuts out services such as checking or pickle-directing, I suppose you could argue that customers are taking the burden of those jobs, but there are always components of customer labor in a business transaction. For example, most restaurants don't chauffeur you from your home right to the table, but we don't describe driving to the restaurant, let alone waiting inside for a table, as working for the business.
Daniel Jalkut on January 23, 2009 5:09 AMSelf-Service Kiosks are not all that complex as you have explained here.
Maybe Self-Checkouts need some time to evolve wrt HCI but speaking of other suck devices such as ATMs they have nearly replaced the Teller completely for banking transactions.
But I agree making a machine to become 100% human-friendly is not as easy as it seems, i still find people struggling with their cell phones just to get used to the touchscreen, at times.
Mohit Nanda on January 23, 2009 5:14 AMThe best thing that governments do is screw up whatever they touch. Should the UN make a office software, you can bet your bottom dollar that they would have spyware embedded into the core. The best way to distribute the wealth is to make it yourself.
Mark on January 23, 2009 5:20 AMI suspect a large part of the problem with OO's slow uptake is its price (or lack of it). Many customers equate price with value - otherwise how could Nike sell shoes at the prices they charge. If OO was sold as a commercial product at, say, 60% of the price than MS Office there would probably be more market up-take and there would be cash to pay programmers.
Robin2 on January 23, 2009 5:26 AMIMHO OpenOffice sucks. Sorry, but it's extremely awkward to use; getting harder with every release methinks. It looks ugly, it is over-designed, etc.
I'm not saying that Microsoft Office is any better, but MS at least tries to make it better - one can argue how successful they are at doing it, but they try. I fail to see that OO even tries!
Whenever I try to make a presentation, a table sheet, or a large text document, I always start doing it in OO... and finally get enough frustrated to give up on it. Usually I end up doing it in a completely different program. Not MS Office (certainly not), but something completely different.
E.g. recently I did a lot of stuff in Apple iWork (Pages, Numbers, and Keynote). These products might still be quite limited compared to the competitors on the market and the performance is still a joke (don't expect to make tiny changes to 50 pages document in Pages... it will freeze your whole system for 30 seconds!), but they have potential.
Mecki on January 23, 2009 5:39 AMIt always takes me a whole lot longer to go through the self checkout; mainly because the software and scanners etc. are all unreliable and poorly integrated. Those things are a design mess.
Also, there is a reason that human jobs are specialized-- practice makes perfect.
Reed Hedges on January 23, 2009 5:41 AMThere's lots of things in Open Office I'd like to fix, really trivial stuff like it doesn't do section numbering properly. Word used to beat it hands down before the latest version where styles became a really confusing mess.
I like o-o for the only show the top-level style not every trivial bit of italics you've ever done, which is what Word used to do.
I *hear* that an o-o build can take a hell of a long time because it's one monolithic thang, not properly modular. I'd love to make the word processor less nasty, but not if I have to screw around building all the other modules I never use and don't care about.
If I could find something (not Abiword, which isn't powerful enough) that just did, say, Word 95 with the multiple views of different parts of the same document that 2007 does I'd be content.
Francis Fish on January 23, 2009 5:44 AMJeff, perhaps you are missing the point of OSS. Take Asterisk for example. Created by Mark Spencer because he needed a PBX for his company. Buying the solution was too costly, so he coded it himself. Asterisk is a disruptive technology, so it makes sense it will garner an active community. Likewise, how fun can it be to code an office suite? Would you blame a fellow programmer for not taking their own free time to code something that might be boring?
theman on January 23, 2009 5:54 AMI've noticed that some of the self-checkouts have been set to be more trusting taking into account things like I'm only buying one item, so I don't need a bag and I can hold it while I'm inserting my money.
Speed is definatley another factor with these devices; I find that I can work A LOT faster then they can.
Having a self-checkout at stores like Home Depot is almost a joke. Let me left that 50lb bag of ReadyMix to scan it...
J. Daniel Smith on January 23, 2009 6:02 AMWhile forcing users to scan each item, one at a time, and force them to be weighted is a pain, here is my REAL pet-peeve...
A local market checked their lookup feature from
'type the first three chars' to
'select a picture of your item from the list' with 26+ pages of images in alphabetical order.
OMfG! what a major step backwards!?
I, the consumer, am able to type AND read!
Why throw me back to the stone ages?
_THE_ major reason I check myself out is that I can do it FASTER than the cashiers!
-sorry to waste my shopping rant in a thread about open-source hurdles
Eric on January 23, 2009 6:10 AMThe REAL issue with F/OSS, which a few comments have hinted at in passing, is what developers seem to forget about behind the F/OSS flag of Get the Source and Fix It Yourself Faster than Proprietary - you're putting maintenance and bug fixes on your customers. While this might work for enterprises that can afford to hire developers to write and maintain this software, the premise falls flat on its face once you reach the consumer market.
Asking Aunt Mabel to code up a bug fix because she can't print a picture of her grandkids that her daughter sent her is not just ignorant, it's downright absurd. There is a reason people buy/download software - it places the responsibility of learning a programming language, debugging, etc. on someone else so they can just use it.
Aunt Mabel shouldn't have to try to learn C++, find the API for her particular printer driver model, and code herself up a custom wrapper just to make OpenPhotoViewer 0.3 function at the level she should expect - click the Print button and the picture pops out in due time.
James on January 23, 2009 6:24 AMI'd love to use the scan-as-you-pick services many big stores have if it wasn't for the fact that it requires registration and that they after this keep a list of EVERYTHING you've bought using this service.
Only to be able to send me more advertisement of stuff I'll probably want to buy.
What I can't figure out with the self checkout is how to use a freaking paper bag instead of a plastic one. If you put a paper bag on right away, it yells at you that a new item was placed in the bagging area and must be removed. And if you try and add it as you place the first item in, it tells you that the weight doesn't match.
The only way I've found I can do it is by having the person working override it, which is a pain in the ass. So alas, I ussually use plastic.
Kris on January 23, 2009 6:31 AMYou seem to be seeing more problems than there are:
What if the item you're scanning isn't found, or can't be scanned?
I've never experienced an item not being found, so this must be very rare. If it can't be scanned, I believe you can enter the code by hand.
How do you handle coupons?
I'm actually not sure if these can be scanned, because they need to be taken or voided manually.
Loyalty cards?
Scan it if it's the keyfob type, or swipe it if it's the credit card sized type.
Buying 20 of the same item?
Scan all 20. It might take a little longer than scanning one and entering the quantity, but given that the scanners these days generally work well and scan quickly, how much more time does it take than scanning one then still having to move the other 19 to your bags anyway?
How do you ring up items like fruit and vegetables which don't have UPC codes, and have to be weighed?
Put them on the scales. Select the item from the categorised menu (with pictures).
What about unusual, awkwardly shaped items or oversize items?
Use the hand-held barcode scanner next to the screen.
He's not having more problems than there are. He's enumerating the error conditions that some user can possibly have. They are complications that someone who does not know the system is, at the very least, going to have to spend some time poking through their interface to figure out.
My problem with self checkout is when it's misused. Like at Home Depot. I have almost never left home depot without at least one item that will not fit on their scale. And my local home depot has decided to close all of the service lanes and just pay four people to stand around looking at the self checkout. One of the worst examples of poor management I've seen.
Also, I'll echo the statements about learning C++ or Java being a barrier. Anyone graduating with a CS degree knows one of those two - they're the lingua franca of programming. Now if you make me learn Ruby, I'll probably thank you afterward, but it'd be much more of a barrier initially.
@James Don't be ridiculous, nobody expects an unskilled user to maintain their own software. There are lots of people working to make Free software as user-friendly as possible.
Adam on January 23, 2009 6:48 AMI hate the hassle of trying to buy beer at a self-checkout.
Eric Belair on January 23, 2009 6:53 AMJeff, another great analysis. Probably the most salient point yet about why self service checkouts are something I love even as others hate on them.
I work with POS software daily as a reseller/support person and you're right on target. Thanks for a brilliant piece again.
@kris: Newer versions of the NCR software will beep at you when the transaction starts and ask you if you're using your own bag, then re-zero the scale.
atroon on January 23, 2009 7:00 AMJosh (3rd post or so),
How in the world could an OSS project have bugs waiting for developers to fix in the amount of detail you list? Who's going to find the source file containing the bug and attach it to the bug? It would take a developer to find the source file. At that point he may as well make the fix himself. 80%+ of all bug fixing is the research. The research is the painful part of bug fixes, the part that's unsexy. Who in world wants to suffer all the pain and not carry through to the 20% of the problem which rewarding: fixing and checking in a bug fix?
And who is writing these specifications? Again, if you have someone around who can write meaningful specs, that person most likely can implement them too (as you noted).
Tutorials on how to contribute: Who has time to write these things?
jmucchiello on January 23, 2009 7:09 AMI have always been perplexed by the elderly couple that routinely ops for the self-checkout, only to spend about 5 times as long as they struggle to understand the prompts.
They always look around as if to say why are they doing this to me?
Did they just not know it was the self-checkout line? Do they think all the lines are that way? I get so frustrated. What in the world are they thinking?
Practicality on January 23, 2009 7:13 AMOne problem I see with OpenOffice is that all they are doing is trying to ape Office. Office is cheap enough and good enough. Heck wordpad is good enough for most jobs. Why give time to that?
Do something new and fresh and better and they will come.
What everyone fails to understand about open source software, as far as customization goes, is that it primarily benefits technology companies who have the resources to develop it further and market the results. Individual programmers do not have the spare time to work on a massive project. Open source web applications are more likely to benefit from a community of developers because minor improvements are easier to make. I'm currently migrating to PHP because the ASP.NET community does not have enough open source web applications available.
Robert S. Robbins on January 23, 2009 7:30 AMThis was a great read, Jeff.
I would ban the IPs of idiiots who submit first comments.
Josh Stodola on January 23, 2009 7:36 AMOpenOffice needs money. And management. But first -- money. The combination of it being massive in size, and not too sexy kills it. You can't just make patches to a 100MB C++ codebase. You'll need to invest a month just to find your way around this thing. That's commitment. Also, products this big can't work with programmers designing the UI, somebody needs to write specs...
max on January 23, 2009 8:08 AMThere is nothing wrong with asking the developers on an OSS project to focus on a single, common language, whether it is C++ or FORTRAN. First, any serious developer who is truly interested in the project should be able to learn whatever language it is that is being used. Languages are just tools. Second, on any project a common communication dialect has to be decided on, or no one can work on anyone else's code. Then it becomes Open Source in name only.
Open source is not Java, it is collaboration.
Zorro on January 23, 2009 8:12 AMThe thing I always hate about the self checkout machines is that when they ask you to type in your zip code for the credit card you just used, the keypad they put on the screen is in a non-standard layout. Specifically, the bottom row consists of the number zero on the far right, not in the center, and the rest of the bottom row is a clear button taking up two buttons' worth of space.
So for example
1 2 3
4 5 6
7 8 9
0 CLEAR
Since my zip code has a zero in it, I instinctively hit where zero should go - which is actually the clear button. So then I have to start over. Once, an employee was trying to help me check out (can't remember why) and when I did the zero/clear thing she actually told me well now you've screwed it all up
I stopped shopping there. They closed.
Schnapple on January 23, 2009 8:17 AMJeff,
Thank you for presenting an interesting topic.
I am, however, a little confounded by the analogy between Self Service and Open Source. In each side of the analogy you 3 tiers of involvement/concern to consider in evaluating success.
In your supermarket example of self service, first there is the store (the owning entity). Since Open Source projects usually do not have owners in the same sense as a corporate entity, we can compare the store to an open source initiative sponsor (such as SUN in the OpenOffice.org example). Next, on the open source side, developers are akin to the self-serve checkout system builders. Finally, in both cases you have the consumer.
As a manager charged with establishing and maintain vendor relationships, I spend a lot of my time thinking about ROI. In this analogy, you and others have clearly identified the ROI for each tier on the supermarket side. The store saves resource costs. The builders get paid for their checkout system. The consumer gets a higher level of control over the packaging of their groceries.
On the other side of the analogy, I don’t find the ROI as clearly. Approaching it form the opposite direction, it is clear that the consumer benefits by free or reduced costs. Also, the developers may benefit by community status, resume building and perhaps even employment by companies that appreciate the impressiveness of their work. These developer incentives have only potential ROI and so are suspect. At the Open Source sponsor level, things get really murky. What is the ROI of an Open Source project? I can only think of one; implementation of strategy. Perhaps (in the OpenOffice.org example) SUN would benefit by getting a “foot in the door” with a free product, or advertising. Perhaps they just wanted to hurt Microsoft’s Office product sales. Regardless, they did it because it was part of a corporate strategy not because of the ROI.
It has always been my opinion that I share with many others, and have heated discussions with Don Norman, and a long time ago Richard Stallman that the lack of clear ROI is the main disconnect with Open Source projects, and in this case why I feel the analogy doesn’t work.
MK
It is quite obvious that you don't work work in the Open Source world.
Open Office is bad not because it is open source, but because the product is so poorly managed. This is true with non open source projects as with open source projects -- poorly run projects produce sucky software.
However, the idea that Open Source is some sort of Socialist Internationale of programming is just out of touch with reality.
Scientific Atlanta and Tivo both base their systems on the open source Linux kernel. Google's Android phone OS is completely Open Source, and so is the new Palm WebOS. Both of these are based upon Linux. I guarantee you that the people who work for these companies don't work as volunteers.
Then, there is the Mac OS which is based on the open source BSD Unix operating system and the open source MACH kernel. Certainly Apple knows how to churn out money.
Then think about all the open source CMS and Blogging software that's out there. Or Google, that behemoth which bases its entire operation on open source projects like Python, JavaScript, Linux, etc.
Open Source isn't bad because it is all self service while propriety software is better because it is more consumer focused. It's that well run projects will produce good products while poorly run projects will produce disastrous products.
David W. on January 23, 2009 8:24 AMJeff missed the obvious Robotic Nation link, so I'll add it here:
http://www.marshallbrain.com/robotic-nation.htm
Scanning a few items when you are in a rush is fine, but scanning a months worth of groceries is way too much effort for me.
As long as your customers are willing or gullible enough to handle the retail work themselves why stop there?
Give them an axe and let them slaughter the cow themselves, and butcher it themselves and wrap it themselves, weigh it themselves, price it themselves and bag it themselves. ..
I love the part that says But to me it's no riddle at all: nobody else in that store cares about getting Jeff Atwood checked out nearly as much as Jeff Atwood does.
If you don't mention this, I just won't think of it.
Argento on January 23, 2009 8:35 AMHad to be done - sorry Jeff!
@`Josh -- WHY did it have to be done?
Heck wordpad is good enough for most jobs.
I'll posit that anyone who finds Wordpad good enough for most jobs does not use enough features of Word (let alone any of the other products incorporated into the suite) to have a serious opinion about the utility of OpenOffice. Heck, Notepad is good enough for most programming, right?
I think the correct metaphor in this case would be to say you're forced to check out someone else's items instead of your own shopping list.
Mark on January 23, 2009 8:48 AMSelf checkout counters are not all the same. In my local supermarket, there are two options: the belt kind and the scale kind. The scale kind seems like what you describe, where the bagging area is a scale that is supposed to be able to tell what you put in it by weight. They *never* work right. I have yet to complete an order with them that didn't have issues.
The belt kind, on the other hand, uses an arch with laser or IR sensors to see which items go through. This is *much* more consistent, and works quite well. The only issues I've had with these are occasional freeze/lockups on large orders... obvious software bugs! ;)
I second the other commenters about the hand-held scanners, too. They work extremely well. On the efficiency level, why load everything into a cart, and then take it out, and then put it back in, and then take it out again at your car? You get to skip one whole cycle with the hand-held scanners, *and* reduce the contention at the checkout.
Tree on January 23, 2009 8:49 AMI don't like the self service lanes.
1) Good checkout cashiers have tons of experience and can complete a transaction in half the time, easily.
2) I like the social interaction with the cashier
3) I met my girlfriend because she was my cashier. I'd hate to think that I could've been dating a self-checkout machine for the past 4 years!
don't forget all this time the cashier messed up and over charged you
happens a lot at wall mart
Great article, Jeff. I like how you took the self-service concept and spun it full circle with OO.o
Matt S. on January 23, 2009 9:01 AMI always use the self-service stations too, but not because they're necessarily faster. Checkstands at grocery stores always have these little LCD TVs which run ads non-stop, and which are not present at the self-checkout stations. I abhor those little ad factories; I would much rather do all the work myself than be a captive audience for any length of time. This emotional experience with grocery stores has so biased me toward self-checkout that I always prefer it, even in non-grocery institutions which don't have the ad TVs.
As an aside, the practice of posting ad displays near checkout stations reminds me of your blog post about people who pollute forums with advertising posts, except instead of being victimized by my peers I'm victimized by the store I'm patronizing. I tend to interpret this practice (probably incorrectly) as a lack of character on the part of their decision makers. I would change stores entirely to avoid them, except that all the regular grocery stores have them now. If I start seeing these things on the self-checkout, I'll probably stop going to grocery stores entirely and just shop at Trader Joe's or something.
Andy on January 23, 2009 9:02 AMMy bugs are not fixed. Well, I can buy MS Office with maybe 2 days salary. How long would it take from me to implement features to OpenOffice? There is no limit to that.
Surely OO would be greater than MS Office if implementing features was easier. But software development has such intricacies that it takes really much effort and patience to achieve something. Plus that you need to co-operate with others.
I have good ideas for office software, but I don't have the time or strength to build them. Also many others don't seem to have either. And there is a paradox in here. I create software for my living. I don't want to see even more software development work eg. programming and so on in my spare time.
Silvercode on January 23, 2009 9:03 AM@jmucchiello:
Who has the time to write tutorials? I'm not talking about project specific tutorials but detailed general tutorials on patching, committing etc. I've read a couple, but they aren't very good. I think Scott Hanselman's was the best I read.
If no one has the time to contribute community valuable information such as 'how to help us', how do they find the time to contribute to community valuable code? It HAS to be the same people doing both. If no one has the time to do the former, then no one has the right to complain about the stagnation of OS projects.
I stand by my claim. The entrance barrier for contributing to OSS is high and overwhelming unless you're extremely interested in the product in the first place.
`Josh on January 23, 2009 9:03 AMthe store is making you do work they would normally pay their employees to do
AND, they're still raising prices through the roof!! Its like outsourcing. The CEO thinks and says hes saving money, but then like Bank of America has taught us, the outsourcing just doesnt work.
Self-service does nothing for the customer.
Mike on January 23, 2009 9:05 AMI'm not feeling your comparison with self-checkouts. In fact, I'd say it is a ridiculous comparison that pollutes the rest of the article. There are virtually no parallels worth commentary.
And are you seriously claiming that asking for C++ is too onerous for an open source development project? Sorry, Jeff, but being a C is hard! guy, it's doubtful that you and people who agree with you have anything to offer these projects.
Countless open source projects are stunning successes (and few of the contributors are Scratching their own itch, which would justify your ridiculous analogy. Most of them are developing for the sake of the goal), despite incredible barriers to entry. You ignore all of those because they counter your absurd lesson.
Open Office is failing because developers aren't excited or motivated by the project.
Seriously on January 23, 2009 9:12 AMI hate the self-service checkout - on principle. I see it as a symbol of the decline of real customer service. I'm a New York shopper - I buy what I need for a couple days at a time, and I go to the store quite often. Most of the time, I find a long line at the self-checkout stands, and I go searching for a regular checkout, and will often find one with *nobody* waiting. Since I only have maybe 5 items max, I can get through and go on my merry way. And I'm always sure to give a big smile to the folks still waiting in line at the self-checkout.
So it's in my best interest most days to have the store employees do their job. This is often how I feel about Open-source software. I often choose commercial software because I don't want to have to service it myself. I'm a programmer and I love coding, but I want to work on my own projects, not on basic tools like Office software, or operating systems.
Jasmine on January 23, 2009 9:14 AMThe best software is written by energetic small groups of people highly motivated by craftsmanship and money. What you get with OSS projects, especially big ones, is the spirit-deadening features of Soviet five-year planning, plus bickering. Crap on Adobe all you like, but they've got incomparably better alternatives to Gimp, Scribus, Quanta, et al. (Oh yeah, and they contribute to OS development in a very reasonable and rational way - just ask Mozilla; though they probably won't tell you how much Adobe brains are behind Chrome etc.)
runbei on January 23, 2009 9:19 AMThe opposite to the self-checkout has struck my local market. At the new Hannafords you can give your carriage of stuff to a checkout employee and then go out and pull your car up to a check out port. They scan and bag all your stuff and then bring it out to your car with a slip. You hand then cash/check/credit card and they go back into the store get your change/validate your check/process your credit card and then return with your slip.
Slow and inefficient but there are plenty of rich people who just love to be waited on.
What does this have to do with open source? Nuttin' :)
Joe on January 23, 2009 9:33 AMHere's the biggest part I see left out of your analogy.
You generalize yourself to the entire population. At least in my area, the self serve kiosks are not heavily used (based on my limited shopping experience). I myself avoid using them unless absolutely necessary. Why?
Your average trained employee is faster than your average customer. Noone is more interested than me in getting me checked out, but the majority of that (unless I have 30+ items) is not check-out time. It's line time. And in my experience line time is no better, and often worse, in those kiosks.
While you may be the most interested in checking you out fast, you may not be the most capable. And even if you are more capable, most customers aren't. So you're not really helping yourself.
This reminds me of the line problem. Lots of research has show that a single queue with multiple cashiers, is faster than multiple queues where the cutsomer picks one. So why does *anyone* have multiple queues?
Well it turns out that despite the proven suckitude of the multiple queue system, customers *feel* better about it. They have control. The fact that the control results in a lower quality product is irrelevant to them. In fact, most would vehemently argue that they have chosen the best way... but that's another aspect of human psychology.
It's the same with open source. Developers love it because it gives them that feeling of control.
Russ on January 23, 2009 9:53 AMfollowup:
This is different from the barriers point, because even with very low barrier systems, the trained personnel are *still* faster.
Russ on January 23, 2009 9:54 AMWhen I read the store is making you do work they would normally pay their employees to do, I agree, this is obviously true, and I wonder what people think when they accept whatever.
But I'm not sure this example applies to OpenOffice.org : more not-Sun developers will understand OpenOffice.org source code, and more the code will become free for true.
Talking about something I know, since the Mac OS X port started, the not-Sun contributors like me progressively started to understand the -ocean of - source code, and now, there is a second step : they start adding features, and even more.
Just another point of view
@Bruno : excepted the micro cws in 1.1.x tree, I never seen any IBM code in OOo ;)
--
q#596;#7433;#633;#601;
Love the self serve tills in MOST cases - there are a few border cases at home depot that I avoid (nuts and bolts, linear feet of base board), and too many of them require everything onto the scale (got too much stuff? back to the traditional till...)
Fruits and vegetables? Work great at SuperStore. You get pictures. Works BEAUTIFULLY. Not sure how well it will work once I get past 3 bags. Walmart at least lets you take the bags off once weighted - Home Depot's tills freak out.
Anyone remember the promise of RFID carts? Push them into a reader, bang, instant and total sum you could then pay for a pack? (or course, some ass will switch tags and suddenly 2$ items will be 20$ items and you would have no way to actually know unless the cart kept a running tally with rfid as well) There is the ultimate self checkout, no need to scan and weigh.
as for Open Source....
I've TRIED to get involved with a project or two in the past. What I found, even from other developers was a cuture of elitism whereby newcomers were -NOT- welcome, and even reported security concerns and changes were unwelcome because they stomped on someone's feifdom.
The problems with open source projects go from top to bottom and most are doomed for failure simply because there is no apparent reason to tolerate the treatment. It is open source, its free, and frankly there are a million alternatives. As such, most projects eventually drive potential contributors away.
Linux is one of the few exceptions, but even then, you can see the power stuggles happen. The only reason it has held together this long is the cult of personality around Torvalds. When he is no longer available to reign over the masses, chaos will inevitably descent and no one else will have a clear enough claim to authority to keep things running and the standard pattern will repeat.
At least in closed source commercial development, who is in charge is ALWAYS clear - the guy with the money. While there are a million things than can kill commercial development, at least the final authortity issue is dealt with.
Xepol on January 23, 2009 9:58 AMThe self-checkout thing is more a social phenomenon than an economic one.
The relationship between service provider and customer at chain stores has already deteriorated to the point where they are little more than talking ATMs with fancy AI. They can't accept tips, they aren't allowed to have a conversation with you, and they're judged on how fast they shove you through the line -- being anything more than a vending machine with a smile is looked down upon.
Customers like that because it's getting less and less common to see people treat each other as people, instead of resources to be made use of. Employers like that, because it increases efficiency. Tellers don't get a say in the matter if they want to keep their jobs.
Putting in real machines, instead of people forced to act like machines is the next logical step.
Consider this: Excluding the lineups, it's usually faster to go through a normal checkout than a self-serve one. The teller is much faster at processing CCs than you are with the stupid signature pad, and the physical setup the teller has (the belt feeding her your groceries) also improves her performance. But you will typically feel that it's the other way around.
This is related to the old tests done in the 80s that show that using the mouse is faster than using the keyboard for equivalent tasks, regardless of what the user felt was faster:
http://www.asktog.com/TOI/toi06KeyboardVMouse1.html
Because of the context switches required to interact with a person, the fact that we have to wait on them for tasks to finish, rather than doing it ourselves (however slow), and that general social skills in this area have degraded to the point where interaction is awkward -- all of these things combine to make it feel slower to deal with another person, regardless of the fact it's almost guaranteed to be faster.
Therac-25 on January 23, 2009 10:06 AMRegarding the even if I create a bugfix, I cannot publish it widely enough: yes, I think that's a problem esp. if lots of scratch-your-itch developers make small fixes for some project. For example, I have some patches lying around (in a public personal repository) for a project where:
- the original author hasn't done anything for years (probably he doesn't need the software anymore)
- a Sourceforge page exists which has the latest code imported by the original author but no further additions
- several discussion about this software are littered all over the net
- code fragments, patches, VCS repos, or tarballs with patched sources can be found on the net
In summary, there are some people interested, and some people have contributed, but there is no leader anymore, and there is no central place which links to all these fragments.
So, what would be cool: some way to link these fragments. Maybe a special syntax which every developer can add to his software to link to other contributors, and then some web crawler (or a Google-based system) finds those links and automatically puts it together into a big repository view? Or some p2p net to find other developers and their code?
I think it's important to not require the developer to join some group (or create a SourceForge/GitHub/Launchpad/whatever account; or use the same VCS; or take the other fragments into account). The developers should still be able to scratch their itch and then put the software or patch online in their liking (maybe in a repo, or in a blog, or on Rapidshare, or even in a pastebin); and some automatic system links it together and shows: hey, there's ten people all working on this, and together they have already contributed three times more than the original author did! This project is alive!
Well, that would be cool. That, and having an infinite icecream box.
One more comment on open source in general. The main problem I have with most open source projects is that there are plenty of people involved and not all of them are good coders. The code is a mixture of people just started to learn the language, experienced programmers, and real pro-hackers. This mix usually results in a big ball of mud - or to put it in simpler terms: The code is a mess.
Whenever I just want to fix a tiny issue, I see the code and feel the strong urge to rewrite this whole piece of crap into something that deserves the name program code. The problem is: The tiny fix could be coded within 10 minutes, the whole rewrite takes several hours. I'm willing to spend 10 minutes on fixing the issue, I'm not willing to spend hours to rewrite other peoples mess. On the other hand I'm also not willing to add my well designed patch into this ball of mud... in some cases I can't because what seems reasonable code on its own might break the existing code in so many ways, however, I can't tell because working yourself through the code is so much PITA.
I end up just reporting the bug, giving some details on how I think it should be fixed, and leave the coding to someone else who is willing to dive into the mess.
Mecki on January 23, 2009 10:17 AMHonestly, an online IDE would solve a lot of these problems. It would be great to have a Google doc type application with the features of a modern development environment. That would put everyone on the same page with the same software. No more compatibility issues and the bug repository could actually link directory to the problem source code.
Make it happen, Google.
Charles Callebs on January 23, 2009 10:25 AMToo many ravishing beauties - distractions.
Too bright and sunny - blinding.
Going south - not advised.
Bang! Boom! -- No.
The problem with Open Office is that developers don't use office.
I second that. Office software is booooring!
Joe Beam on January 23, 2009 10:45 AM'I've seen plenty of customers in front of me struggle with self-service checkout machines, puzzled by the workings of this mysterious device that seems so painfully obvious to a programmer. I get frustrated to the point that I almost want to rush over and help them myself. Which would defeat the purpose of a.. self-service device.'
So, so true. I've felt this way many times and can't understand how something so painfully simple can be so misunderstood. Guess that's just me thinking in a different way :)
Daid Workman on January 23, 2009 10:52 AMAnd then the perfect follow-up post is next right?
StackOverflow is now Open Source
;)
Scott on January 23, 2009 10:57 AMIt's entirely possible that many people feel that it's 'good enough' as it is. Most people want to write or open a document, or make a spreadsheet... that's it. If it can do that, it's 'feature complete' for most people - why bother adding to it?
Steve-O on January 23, 2009 11:12 AMThe software in a self checkout system is a clear example of good software gone bad by silly requirements from clients.
Using self checkout systems around me, I can tell that the software was originally designed in a usable, painless manner.
Then, management was afraid customers would steal items, so they put in these HORRIBLE weighing systems that stops you from taking items off the bench early, or from setting them there before you have scanned them (which is often helpful for space reasons).
THEN, it was realized that everyone accidentally triggered this stupid weighing system, so the system would freeze constantly, which would require constant staff interaction to unfreeze.
To fix the above problem, the customer can simply press a button to dismiss the error and continue as normal.
So now, they've ended up with a system with all the annoyance and hassle of the weighing system, yet NONE of the intended security benefits, since a customer can just clear the error themselves. A once painless system is now cluttered with useless warning messages that simply frustrate, annoy, and slow down the users.
Oh, and don't get my started on the fact that an employee has to key in a code for certain items like alcohol.... they do it on a GIANT touchscreen keypad right in front of your face. If I was so inclined, I could easily enter the code myself, it's only 4 digits.
TM on January 23, 2009 11:49 AMThe answer is stupidly simple.
If you let just anyone work on OO, there is a very good chance that the code quality will suffer. That's the reason all of these restrictions are in place, to maintain quality. This is a good ambition, but totally wrong.
A concrete suggestion to OO is to stop focusing on bureaucratic QA and focus on techical QA. Spend your effort writing test cases, standards checking tools, etc... and leave just a few eyes to look at the code after it has been smoke tested to shake down if it's worthy of inclusion. Kill the CCB. In this way, the barrier to entry is literally that which would not technically degrade the project, and we all win.
Matt Bramlage on January 23, 2009 11:51 AMI also should have mentioned that RFIDs on items could totally fix the problem of checkouts... you could simply pass your cart through a gate, which would instantly recognize all of the items present in the cart.
From there, it's a simple payment terminal, with a few extra checks like age limits for alcohol.
TM on January 23, 2009 11:51 AMThis is only a preview. Your comment has not yet been posted.
As a final step before posting your comment, enter the letters and numbers you see in the image below. This prevents automated programs from posting comments.
Having trouble reading this image? View an alternate.
| Content (c) 2009 Jeff Atwood. Logo image used with permission of the author. (c) 1993 Steven C. McConnell. All Rights Reserved. |
Subscribe in a reader
Subscribe via email
Posted by: |