Todd Mytkowicz, Nicholas Embree, Adam Mork, Michael Minerva
In many projects that arise from a diverse group of people there is usually a balance between
a central control dictating an overarching design vs a free-form process whereby a design is grown
organically from the users / builders of that system. Both design paradigms (the "central dictator"
vs a more "grass-roots" process) take different approach to design. The dictator approach builds
contracts and guidelines for an implementer to follow; it is then up th those that implement a
design to follow those guidelines. On the other hand, the more grass roots based approach uses a
kind of Darwinian model, a survival of the fittest feature so to speak, that pushes implementation
choice based upon their perceived use.
These are two very different approaches to design and one would expect that system implemen-
tations based upon each approach to have very different characteristics. In this project, I would
like to see if we can verify this claim. To be specific, I would like to study the idea of the intention
of a design construct vs how that construct is actually used in practice. I would like to investigate
a few open-source projects that vary in the amount of central control and organization that each
project employs in its social contracts (e.g. openjdk vs Linux vs apache tomcat) and see how these
choices impact the ultimate software implementation.
To be concrete, consider an example. In the Java programming language I have many "tools"
that aid in me in my organization of source code (e.g. objects / classes or packages). When I
build a package I have a particular idea for how that package is going to be used (intention). For
instance, I expect that classes within the package to be largely related in their usage patterns
while conversely those classes would likely be unrelated to classes outside the package. In this
way, packages are an organization construct that embodies a top-down, "dictator" type approach
to project design. This project is interested in understanding, however, whether the way in which
packages are used in an implementation matches the intention of designers of the package system.
The attached PDF to this page has a more detailed writeup of what I am proposing for the class project.
