I laughed when I found the container shown here in our house, because it demonstrates an overly common attitude about reuse of software, right down to the sanctimonious tone: everyone agrees that reuse and recycling is good, so you should reuse this thing that we custom-designed for our particular needs.
Now, maybe the container is built of recycled plastic, in which case it has some practice behind its preaching, but the idea of demonstrating your commitment to the lofty principle that Reuse is Good (friendly to Planet Earth! With a capital "P" and "E"!) by insisting that others reuse your bespoke work is common in software development. There's a good reason for this: finding code that suits your needs is often more work than just writing the code that does the job you need done. The developers who insist that others should reuse their fabulous code often didn't think beyond their own specific needs when designing it, skipping the steps of generalizing the tasks performed to a wider range of related needs and of course documenting their work so that people understand how to fit their work to other needs.
This has been an issue since people began preaching about source code reuse over thirty years ago, and it drove much of the popularity of object-oriented analysis and design. It's interesting that this is less of a problem with semantic web technology, for two reasons that I see:
Reuse of pieces of other work is much easier. If I just want to use a little bit of your ontology or schema or vocabulary, I can, and with RDF at the bottom layer of all of this, aggregation of pieces from multiple otherwise uncoordinated sources is much easier than it is with other technologies that advocate reuse, particularly programming and markup languages.
We can do retroactive reuse. Let's say I declare and use my own bd:photographer property for image metadata. Later, I notice that Dublin Core has a creator property, and only then decide that mine should have been a subproperty of that. I can just add the triple bd:photographer rdfs:subPropertyOf dc:creator to my data and still reap the benefits of reuse: applications that don't know about my bd:photographer property but do know about the more famous Dublin Core one will have a clue about the semantics of my property (that is, that a photographer is a kind of creator of an image) and can treat my property as a stand-in for the dc:creator property.
Essentially, the ease with which we can loosely join small pieces of ontologies and RDF schema makes it much easier to use semantic technology to form a semantic web.
(A side note on object-oriented work: today everyone thinks that paradigm shift just means "big change." When science historian Thomas Kuhn coined the term, he was describing a gradual fading away of research in a given problem area as people worked on new areas and the other one got left behind. Has object-oriented analysis and design faded away as an active area for computer science researchers since its heyday in the eighties? I think so. Try going to the Association for Computing Machinery's www.oopsla.org website and you'll be redirected to the "Systems, Programming, Languages and Applications: Software for Humanity" conference that has folded it in. That conference has an OOPSLA track, but in the titles of the 61 papers presented in that track in 2011, the word "object" only comes up three times. Of course, object-oriented principles drive the code development of Java and several currently popular programming languages, so these principles are still going very strong, but I find it interesting that active research in the area has faded to such a small fraction of where it used to be.)
Please add any comments to this Google+ post.