One type of assumption - or rather, abstraction - is where you assume that everything not specified is explicitly absent. This is the position you seem to implicitly hold, and which is widespread among economists (if they ever examine the underlying philosophy of the field, that is). The other type of abstraction is one where nothing is assumed about things that are left out of the abstraction. Fundamentally, the first type assumes that everything not included is specified as absent, whereas in the second, everything not included is absent from specification, and can take on any (arbitrary) values. The medieval Scholastics had a name for this distinction: they called the first type precisive, and the second non-precisive abstractions.
Though this sounds like a small distinction, it has very interesting implications for the development of a field and, curiously enough, even programming languages.
As you raised the question of economics, I'll include that as an example. There is an excellent paper by Roderick Long on precisely this topic: "Realism and Abstraction in Economics: Aristotle and Mises versus Friedman". One interesting consequence of using only non-precisive abstraction when building economic theory, and assuming that that which is not specified by the abstractions used is not absent, merely unknown, and that the theory should work irrespective of whatever that unknown happens to be, is that the theory always applies to reality, no matter how abstract it may become. Theories built on precisive abstractions have the problem that they apply to reality only in an unspecified way, and only when reality condescends to confirm in some degree to their assumptions. These theories are, needless to say, of much less analytical value, but often much easier to come up with.
I think, however, that for the Slashdot audience, a much better example would be the differences between programming languages based on this view of abstraction. Let's take the idea of class definition in C++/Java and Python.
In C++/Java, if the specification of a class does not include some attribute, it is impossible - without changing the specification - to add or define it later to an object of that class. The assumption is that everything that is not specified in the class definition is explicitly not there. This is analogous to precisive abstraction, because it is assumed that not specifying the presence of something is equivalent to specifying its absence. Python, on the other hand, has no such restriction; an attribute can be added to an object when and where needed, even if the class definition doesn't include it. Python assumes that things not included in the definition of a class are just unknown, not explicitly absent, which fits in with the Aristotelean idea of abstraction as being non-precisive.
Though there are partisans for both types of object systems, it has to be conceded that Python's object system is strictly more powerful/expressive than that of C++/Java, nor does it force the programmer to decide beforehand what to include in his abstractions, enabling a far more 'experimental' approach to development which is closer to how models and programs are actually developed. Though most programmers are not aware of it, design choices in programming languages usually have deep philosophical implications, and thus significant practical consequences.