It has been said before that we stand on the shoulders of giants, building off their successes and achieving the wonders that we do thanks to those who have come before us. Truly, without the work of our predecessors – who often go vastly underappreciated – our society would not be where it is today. That is simple fact and common sense that any field can relate to.
Surprisingly, though, this is easier said than practiced. Take, for instance, Computer Science.
Simply put, through our years of CS studies, we are caught up with everything from the abacus and the ENIAC to the present day, and made privy to the thoughts and theories and best practices, so that we can begin formulating our own theories from where we currently stand, and thus continue the progression forward. Concordantly, the CS curriculum is very different now than it was a decade ago. With advances in algorithms, artificial intelligence, and hardware capabilities, we are able to tackle far greater problems in computing than we could have ever dreamed of approaching with 386 microprocessors. Indeed, it is drilled into us at a conceptual level at Georgia Tech that we should strive to avoid reinventing the wheel, as it were.
Of course, there has to be a certain amount of it within classes, so we can learn how to, say, program in concurrent environments, or observe the behavior of networks under stress to isolate bottlenecks, and so on.
But what of our insatiable egos…
I realize this can be somewhat of a tender subject. Nevertheless, it has become abundantly clear that, given the choice, the average computer scientist would rather reinvent the wheel him/her-self than utilize a software package of very similar nature to accomplish the same task. Whatever the reason (my cynicism claims ego), a lot of time is spent implementing protocols that have already been implemented a thousand times before.
To give a real-life example, Flickr recently announced that they had outgrown their Ruby implementation and would be experimenting with a homegrown solution. Now, I am all for adopting new technologies as the need arises, but there are countless photo management suites out there, numerous well-written and modular technologies that should be able to satisfy the need – at least in part – of any photo host. Building one’s own solution from scratch reeks of professional egotism.
Of course, perhaps I’m just being cynical and judgmental. I will admit that I have succumbed to this inherently human flaw on many an occasion – in fact, most of my personal programming projects are rewrites of existing software. There is certainly merit in doing something for oneself, particularly for the education of the experience. I learn how AJAX works through writing it myself. I learn how bulletin board applications function by writing mods. Nevertheless, to this day I will still credit two particular endeavors as my greatest blunders in this area of reuse: my attempt to write a templated wiki, and my attempt to create a homegrown content management system.
The latter was an interesting culmination of hardcoded HTML and random crashes (all in a single 2000-line PHP file, I might add), and the other never went beyond the inital testing stages (supposedly a combination of the BML and Smarty template systems…yeah, don’t ask me to explain, I don’t get it either).
Like I mentioned previously, this tinkering can be good – indeed, it taught me a lot about template engines, how they work, and what goes into making the beastly Joomla! CMS function as it does – but come on. It’s all been done before!
I had a meeting tonight with my Summer of Code mentor, Amy, regarding my project to make Joomla! an OpenSocial container, meaning that OpenSocial applications would be able to run within the CMS. She discovered the Apache Incubator project called Shindig (for which I’d almost applied to for GSoC, in fact) which is an implementation of OpenSocial, and suggested that, instead of reinventing the wheel, we should utilize their code base in building OpenSocial into Joomla!.
Honestly, I was surprised I hadn’t thought of that before. It was brilliant on all counts. Maybe it was because my CS ego and seemingly innate need to DO IT MYSELF was temporarily blocking out reason.
Of course, all that having been said, one still needs to tread lightly. Yes, open source is meant to be open and useful to everyone…but the nuances of licensing can have the nasty tendency to creep up and bite you in the rear end. Apparently, Joomla!’s GPL v2 license is minorly incompatible with Apache’s 2.0 license.
Furthermore, the state of Georgia recently published a report on how to reform its mental health institution…except, according to the AJC, it was viciously plagiarized from several sources:
By typing phrases and passages from the essay into Google, the Internet search engine, the newspaper determined that every sentence of the essay was taken either from a psychiatric association document, published in 2005, or a 2006 report by the University of Texas’ Houston-area psychiatric center.
The report owes its greatest debt, however, to Michigan.
In this particular case, the bounds for reuse of material were obviously overstepped. By a lot. In fact, I think this is just plain dumb. But the ethical implications of this particular issue are a bit different and more far-reaching than simple PHP module reuse, so I will end my rant here, and leave you with the following lolcat:
The funny thing is…they look like my cat, Salem. O_O