My Masters Thesis:
	"Dynamic Encapsulation of C++ Objects
	   for Distributed Object Oriented Systems" 

Last Partial Update: Monday, February 7, 2000.

News

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.

Old News (July, 1998)

Classes in C++ provide static encapsulation of objects, by generating code which contains specific knowledge about the internals of encapsulated objects. Static encapsulation occurs at compile time, and therefore cannot directly support the evolution of objects, since recompilation of source code is required if the internal layout changes. This also prohibits the use of distributed or persistent objects without first ensuring that the internal representations of the objects match the ones in the compiled code.

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++.

• Andrew Kitchen
• Warren Carithers
• Peter Anderson

• Thesis Proposal (from March, 1996)
  • proposal.ps
• Working draft (February 7, 2000)
  • thesis.ps
  • thesis.2.ps (2-up version)

All of the code for the thesis will eventually be made available from my ShagWare page. Currently, an old pre-release of DECO is available.

*** It's finished!!! (the defense that is, not the whole thing) ***
• June 22, 1997, 10-11AM
• Rm. 10-1124 (at R.I.T.)
• announce.ps (Announcement - Postscript)
• announce.txt (Announcement - text)
• defense.ps (Slides - full size)
• defense.8.ps (Slide handouts - 8-up)

back to my homepage (meet the author)