Based on threads on iNES and SPC700 mnemonics ... I've been thinking a bit more abstractly about the nature of collaboration.
In almost all cases, there isn't one glorious truth. Everything has various trade-offs, and these trade-offs vary in importance based on the individual. If there were a universal correct way, I'd like to think we would gravitate toward it naturally. Much like in math, no one (sane) will argue the point that 2+2=4. That self-evident correctness is absent for a reason.
And so it seems that a necessary component to a successful project is to have a strong leader. When two equally talented individuals come up with separate solutions to the same problem, you need someone to pick one and move on to the next issue. In the corporate world, this is the CEO.
But we're not in a corporation, so we all work for free, with collaboration being our only tool. In the open source world, you see these roles filled by the likes of Linus Torvalds and Theo de Raadt. Yet here, these types of leaders tend to put up with a lot more. In the corporate role, you'd be fired for insubordination. In the open source world, you have to constantly deal with people undermining your efforts. I think this leads to extreme embitterment. Linus and especially Theo are extremely hated by many. They're extremely blunt. Yet they're effective at what they do. There's no arguing that Linux is the strongest open source operating system, and OpenBSD truly excels at security, making it a fantastic choice for a server.
I think that these projects are so successful not in spite of their leaders, but because of them. The brashness being an unfortunate yet necessary side-effect of dealing with the public constantly.
The real breakdown starts to occur when we approach the less organized communities, like emulator development. Every NES author here likely has their own ideas on how things should be done. And there's no clear leadership, nor am I suggesting there should be. Instead, everyone feels themselves to be an equal (or perhaps even above equal) participant in the community.
When I think of myself working on software, I continually come back to the fact I'm not being paid anything. Why would I listen to a bunch of other people who disagree with me, and produce something I can't personally respect? It's not so much a narcissism in thinking oneself is absolutely right. Certainly, input from others routinely shapes our opinions and is reflected in our work. It's just that they don't play a trump card over our own ideas completely. We still want our own expression.
And indeed we couldn't just go simply based on others' input: it's so diverse that you would doom yourself to an unholy mess that ended in failure. I've been down this road, too. You try and please everyone, and you end up with an emulator that supports 15 compression formats, ten different ways to load NES games, seventy five filters because one guy is just really passionate that 2xSaI-Bold is the one-true-filter. And all of this code interacts with each other, and you start getting into insane interdependencies and conflicts that bog you down to the point where 100% of your development time is spent trying to please everyone. And your UI ends up so convoluted that nobody can figure anything out anymore. They go to map their input and are presented with a 1200x800 window positively packed with 100+ controls because one of your users wants to play Super Mario Bros using his cell phone as the controller. And now your tablet user is complaining that the input config window won't fit on his 1024x768 screen. You just can't win when you try and please everyone.
Obviously I don't think anyone wants a world where every last piece of software has zero interoperability. I know I like all my desktop apps to look and function the same way. Code reuse in some cases is not just convenient, but essential. Think crypto libraries: not something you want to make up without decades of experience in the field and tons of peer review. Yet at the same time, I also shudder to think of a world with no choice.
This leads to an interesting philosophical conflict: when I use GNOME 3, and Windows Metro, I am absolutely aghast at how miserable the experience is. I couldn't imagine being forced to use one of these, with no Xfce alternative. I am constantly loudly vocal about how godawful the experience is to me. But I do recognize that some people, for reasons beyond my comprehension, enjoy these desktop environments. So how hypocritical am I when I write my own software to do things my own way, and force others using my software to change to suit my interests?
So ultimately, I think we're left in a situation where we have to strike a middle ground. Choice, but not too much choice. Restrictions, but not too many restrictions. A nightmare scenario for an idealist like myself.
And then I look to the motivations of individuals.
The first category I see are the conformists. Here, code reuse is quintessential. Surely one individual can't do better than the hundreds of individuals who have worked on the same problem already. There is no need to reinvent the wheel, you're just suffering from not invented here syndrome.
The second, are the idealists. Backward-compatibility is thrown to the wind. Seeing backward-compatibility as a crutch that infinitely bogs down progress, the optimal solutions to problems are sought. Nothing is sacred, everything is open to re-evaluation.
The third, are the arbitrators. Oft-futile efforts are made to bridge the gap between the first two categories. It's a great struggle, as sometimes this results in a stronger unified standard, and sometimes it results in a mediocre version of both competing standards. And of course, they have to deal with the extremes from both sides. Worse yet, their goal is to produce one standard, but they end up just producing yet another standard instead.
And rather than pigeon-hole people into one category, it's likely more of a scale:
<conformity .................. arbitration ................. idealism>
In particular, I feel the conformist category are very averse to change, the idealists are self-absorbed, and the arbitrators follow the road to hell paved with good intentions. Nobody gets off as the white knights here. Each has their strengths and weaknesses.
Absolute focus on reuse and compatibility would have us all using 16-bit DOS apps to this day. Absolute focus on idealism would have our entire ecosystem thrown out yearly with new languages and toolkits. And absolute compromise requires us to port our applications to five different toolkits using different languages for each. All of these options suck in their own way.
And that gives us the software scale of:
<compatibility and flexibility ............ compromise ............ elegance and simplicity>
The interesting paradox is that the category I personally reside in changes based on whether I am the developer or the user. When I am developing, I am a strong idealist. Yet when I am using others' work, I am more of a conformist. And I think the latter is mostly because I'm so disagreeable with some of the horrors out there. It's probably a reflection of me realizing how far from the mainstream my own ideas are, that I'd hate to be forced to follow this new trend that tablets and desktops should be exactly the same.
Hammering down exact definitions is quite challenging. An absolutely rigid conformity to a specific solution is a form of idealism to those who find that existing solution optimal. And an idealist ultimately wants everyone to use only one solution, despite the reality that the attitude to improve things ultimately produces the most options.
In closing ... no great epiphany or "this is what we should do" to this post. Just musings on the topic in an attempt to understand where all sides are coming from.
In almost all cases, there isn't one glorious truth. Everything has various trade-offs, and these trade-offs vary in importance based on the individual. If there were a universal correct way, I'd like to think we would gravitate toward it naturally. Much like in math, no one (sane) will argue the point that 2+2=4. That self-evident correctness is absent for a reason.
And so it seems that a necessary component to a successful project is to have a strong leader. When two equally talented individuals come up with separate solutions to the same problem, you need someone to pick one and move on to the next issue. In the corporate world, this is the CEO.
But we're not in a corporation, so we all work for free, with collaboration being our only tool. In the open source world, you see these roles filled by the likes of Linus Torvalds and Theo de Raadt. Yet here, these types of leaders tend to put up with a lot more. In the corporate role, you'd be fired for insubordination. In the open source world, you have to constantly deal with people undermining your efforts. I think this leads to extreme embitterment. Linus and especially Theo are extremely hated by many. They're extremely blunt. Yet they're effective at what they do. There's no arguing that Linux is the strongest open source operating system, and OpenBSD truly excels at security, making it a fantastic choice for a server.
I think that these projects are so successful not in spite of their leaders, but because of them. The brashness being an unfortunate yet necessary side-effect of dealing with the public constantly.
The real breakdown starts to occur when we approach the less organized communities, like emulator development. Every NES author here likely has their own ideas on how things should be done. And there's no clear leadership, nor am I suggesting there should be. Instead, everyone feels themselves to be an equal (or perhaps even above equal) participant in the community.
When I think of myself working on software, I continually come back to the fact I'm not being paid anything. Why would I listen to a bunch of other people who disagree with me, and produce something I can't personally respect? It's not so much a narcissism in thinking oneself is absolutely right. Certainly, input from others routinely shapes our opinions and is reflected in our work. It's just that they don't play a trump card over our own ideas completely. We still want our own expression.
And indeed we couldn't just go simply based on others' input: it's so diverse that you would doom yourself to an unholy mess that ended in failure. I've been down this road, too. You try and please everyone, and you end up with an emulator that supports 15 compression formats, ten different ways to load NES games, seventy five filters because one guy is just really passionate that 2xSaI-Bold is the one-true-filter. And all of this code interacts with each other, and you start getting into insane interdependencies and conflicts that bog you down to the point where 100% of your development time is spent trying to please everyone. And your UI ends up so convoluted that nobody can figure anything out anymore. They go to map their input and are presented with a 1200x800 window positively packed with 100+ controls because one of your users wants to play Super Mario Bros using his cell phone as the controller. And now your tablet user is complaining that the input config window won't fit on his 1024x768 screen. You just can't win when you try and please everyone.
Obviously I don't think anyone wants a world where every last piece of software has zero interoperability. I know I like all my desktop apps to look and function the same way. Code reuse in some cases is not just convenient, but essential. Think crypto libraries: not something you want to make up without decades of experience in the field and tons of peer review. Yet at the same time, I also shudder to think of a world with no choice.
This leads to an interesting philosophical conflict: when I use GNOME 3, and Windows Metro, I am absolutely aghast at how miserable the experience is. I couldn't imagine being forced to use one of these, with no Xfce alternative. I am constantly loudly vocal about how godawful the experience is to me. But I do recognize that some people, for reasons beyond my comprehension, enjoy these desktop environments. So how hypocritical am I when I write my own software to do things my own way, and force others using my software to change to suit my interests?
So ultimately, I think we're left in a situation where we have to strike a middle ground. Choice, but not too much choice. Restrictions, but not too many restrictions. A nightmare scenario for an idealist like myself.
And then I look to the motivations of individuals.
The first category I see are the conformists. Here, code reuse is quintessential. Surely one individual can't do better than the hundreds of individuals who have worked on the same problem already. There is no need to reinvent the wheel, you're just suffering from not invented here syndrome.
The second, are the idealists. Backward-compatibility is thrown to the wind. Seeing backward-compatibility as a crutch that infinitely bogs down progress, the optimal solutions to problems are sought. Nothing is sacred, everything is open to re-evaluation.
The third, are the arbitrators. Oft-futile efforts are made to bridge the gap between the first two categories. It's a great struggle, as sometimes this results in a stronger unified standard, and sometimes it results in a mediocre version of both competing standards. And of course, they have to deal with the extremes from both sides. Worse yet, their goal is to produce one standard, but they end up just producing yet another standard instead.
And rather than pigeon-hole people into one category, it's likely more of a scale:
<conformity .................. arbitration ................. idealism>
In particular, I feel the conformist category are very averse to change, the idealists are self-absorbed, and the arbitrators follow the road to hell paved with good intentions. Nobody gets off as the white knights here. Each has their strengths and weaknesses.
Absolute focus on reuse and compatibility would have us all using 16-bit DOS apps to this day. Absolute focus on idealism would have our entire ecosystem thrown out yearly with new languages and toolkits. And absolute compromise requires us to port our applications to five different toolkits using different languages for each. All of these options suck in their own way.
And that gives us the software scale of:
<compatibility and flexibility ............ compromise ............ elegance and simplicity>
The interesting paradox is that the category I personally reside in changes based on whether I am the developer or the user. When I am developing, I am a strong idealist. Yet when I am using others' work, I am more of a conformist. And I think the latter is mostly because I'm so disagreeable with some of the horrors out there. It's probably a reflection of me realizing how far from the mainstream my own ideas are, that I'd hate to be forced to follow this new trend that tablets and desktops should be exactly the same.
Hammering down exact definitions is quite challenging. An absolutely rigid conformity to a specific solution is a form of idealism to those who find that existing solution optimal. And an idealist ultimately wants everyone to use only one solution, despite the reality that the attitude to improve things ultimately produces the most options.
In closing ... no great epiphany or "this is what we should do" to this post. Just musings on the topic in an attempt to understand where all sides are coming from.