This is a thesis that I'm currently working on to complete my Masters of Science in Computer Science requirements at the Rochester Institute of Technology.
My Masters Thesis: "Dynamic Encapsulation of C++ Objects for Distributed Object Oriented Systems"
This page has sat here for 4 years and due to being busy with a startup I never really had time to update it, but I figure it's probably about time I mentioned that the thesis *IS* done, and has been since the end of February, 2000. (yes, 4 years ago) So I finally officially got my Masters Degree in CS (Systems Software) from RIT in March that year, 6 years after starting the program, and 4 years after starting the thesis while working full-time. (most people familar with the project said I should have just done a PhD with it)
Nothing else on this page has been updated yet. I'm tired, so I'm going to bed soon, but I'll be updating this page soon with all the updates.
It's been ages (over 6 months) since I last updated this page. Yes, I'm still working on my thesis, in what little free time I get. My current job working on the Inferno project at Bell Labs (Lucent Technologies) continues to be very demanding, and takes up most of my time. Also, as I mentioned on this page once before, my thesis turned out to have far too many subprojects which were all very time consuming and could have each been separate theses (such as SHACC).
I think I said something before about having everything finished by the end of 1998. Well, obviously I was wrong. I won't attempt to speculate again about when I'll be done until I get over certain hurdles that are still causing me trouble.
Dynamic encapsulation occurs at run-time, and allows the compiled code to exist without the knowledge of any particular object representation. Abstract base classes with C++ virtual functions support a limited form of dynamic encapsulation, but only for objects originally designated to inherit that class. Some languages, such as Smalltalk, support dynamic encapsulation, but with significantly less performance than statically encapsulated languages.
An object model using dynamic type-binding is presented that allows the flexibility of dynamic encapsulation with much of the efficiency of static encapsulation. With this model, objects can potentially communicate and migrate across address space and network boundaries without specific prior knowledge of representations, and can invoke functions on local objects with no more run-time overhead than standard C++ virtual function calls.
This dynamic encapsulation model is incorporated into DC++, a C++-based language with extensions that allow for the dynamic encapsulation of existing C++ objects, and DECO (the Dynamic Encapsulator of C++ Objects), a utility for converting DC++ source code into C++.