Fog Creek Software
Discussion Board




Applying One theory in many different areas

I am a recent CS graduate as some may remember me from my last post.  As I wanted to broaden my knowledge in CS, I took maximum allowable senior courses.  However, one thing I truly learned, is that there are so many overlapping concepts, it seems to be possible to unify everything to just a handful of theories.  And most are related to some graph theories, in one way or another. 

Example, not long after I learned about garbage collection in the compiler class and how it is done, I subsequently learned the same thing in the distributed system class.  Though they are essentially the same, the “data” in each is different; one is for memory and the other is for names in database.  It is obvious enough, some if not most, in the distributed class would have quickly recognized the same theory can apply in cleaning up memory, even if they have never taken a compiler class.  (Note, I would have been happier, if the prof mentioned about other application, but she didn’t)

Anyway, I’m wondering if there is a book that talks about how a theory is being applied in different areas of CS.  Or better yet, a theory from totally different field (ie, Education) can be applied in CS.

MR
Thursday, June 05, 2003

I think you have hit upon what I think of as "the secret of life" -- everything is essentially the same pattern. I am not too well-versed in Computer Science, but off the top of my head, I think "Goedel, Echer, Bach" by Hofstadter shows this in action.
However, I have also come up with my own corrollary to this "everything is the same" theory:

Detailed Theory                    Vague Theory
<-------------------------------------------------->
Narrow Application              Wide Application

~This is a "spectrum of abstractness" -- the more general a theory, the more places it can be applied (e.g. using a pointer/lookup/url to refer to one "thing" many times is way better than repeating that "thing" over and over in different places). But at the same time, it will not explain all the intricacies of everything. For the fine-grained detail, you wind up with more specific theories, that can not be as easily applied to different situations (e.g. use numbers for ID lookups in a database as opposed to text values because the computer can search these faster).

Please excuse my rambling -- I just finished a presentation with a client that went really well and am feeling very philosophical.

Jordan Lev
Thursday, June 05, 2003

Which see: Abstraction.

The *trick* is recognizing the law of diminishing returns in pursuit of the "greater good"

The more abstract you can make something, the broader the application for that thing. However, the more abstract you make it, the harder it will be to develop against.

So - when do you stop trying to build the be-all design and accept some shortcomings for the sake of workability?

Therein lies the secret...

Philo

Philo
Thursday, June 05, 2003

Go back to some of the fundamental work, not by Turing (though that's worth it too), but Shannon, Nyquist and so on.  Their work was in communication theory but all of it is applicable to computational problems.

For instance, the computing equivalent of the speed of light is (2 log n) and that is derived  directly from Shannon's theorem.

It doesn't just relate to the capacity of a given memory less channel but to any analagous process.  Shift bits and it applies, search indexes and it applies.

Simon Lucy
Thursday, June 05, 2003

I'm not familiar with it personally, but I have heard "Category Theory" called the grand unifying theory of computer science.

My JOS Alias
Friday, June 06, 2003

Ultimately you can abstract things to as high a level as possible, at which point everyone gets confused and it gets inapplicable.

You will lose a CS class completely, many experienced developers will distance themselves from people who try to abstract or over generalise. Joel has a nice term for them: Architecture Astronauts. People in pursuit of the Unified Code Theory or something.

Ultimately specifics are what we deal in, abstraction helps but only to a point.

Richard
Friday, June 06, 2003

*  Recent Topics

*  Fog Creek Home