COM+ to .NET: Fast Forward Your VB Components

Originally published at O’Reilly

The joke goes: “How do you pronounce ‘C#’?”, and the punch line is: “The language formerly known as Java.”

Extending this, you can say that .NET is “…the infrastructure formerly known as COM/DCOM.”

The .NET infrastructure is significantly different from COM/COM+. However, information about .NET has been out long enough so that most of you have passed the “But, why?” stage. You’re probably now interested in discovering how you can continue to create and support your existing component development to be ready when your organization adopts the production release of .NET. In particular, if you work with ASP and make use of COM+ components created with Visual Basic, you’ll be interested in how you can ensure that your components migrate well to the new .NET environment.

We’ll take a look at some of the changes .NET will have on your current VB ASP component development efforts. In particular, we’ll look at what you can do now to ensure your components are forward compatible with .NET.

What Variant?

One significant change between COM/COM+ and .NET is that the Variant data type is no longer supported; its functionality has been incorporated into the Objectdata type. For Visual Basic programmers this is a major change, particularly if you’ve worked with component development and have used variants to pass data to and from component methods.

For future compatibility, you can begin to use specific data types rather than the Variant in your new components. However, if you have used Variant in existing code, be aware that Microsoft has provided two means of porting your components that contain variants to .NET.

The first is the Visual Studio Upgrade Wizard, which is automatically engaged when you open your older VB code into Visual Studio .NET for the first time. This wizard replaces all instances of Variant with Object, and any time you try and type in a Variant, it replaces it immediately with Object. No additional effort is necessary on your part.

For instance, if you had a subroutine such as the following:

Sub test (ByVal varValue As Variant)

The upgrade wizard changes the subroutine to:

Sub test (ByVal varValue as Object)

If you didn’t provide a data type for a variable in VB 6.0, defaulting to a data type of Variant, the upgrade wizard automatically redefines the variable as Object in VB.NET.

(The upgrade wizard performs other upgrade modifications that will be highlighted throughout this article.)

You don’t have to open and convert a compiled component to .NET to ensure compatibility with the environment. A second means of porting your components to .NET is the utility, TlbImp. How to use this tool was discussed and demonstrated in a previous article; basically what happens is the tool creates a .NET assembly for the component that allows it to run within the .NET managed code environment, without having to recompile the component.

Dropping Variant isn’t the only change from VB 6.0 to .NET. VB Data Types and type checking is another significant area of change, which is discussed next.

Data Types and Data Typing

A chief concern about Visual Basic in the past, particularly from C++ or Java programmers, has been that Visual Basic is a weakly typed programming language. For instance, you can concatenate a number with a string in Visual Basic 6.0, and VB will automatically convert the numeric into a string value, using implicit conversion, as shown in the following example:

iValue = 123
StrSum = iValue & "123"

This type of operation is still allowed with .NET when using the overloaded concatenation operation (‘&’), as shown above, but any other use of numerical values where a string is expected will generate an error. As an example, you won’t be able to pass a number through a string parameter and have VB automatically perform the conversion:

Sub tstValue (String strValue As String)
Dim iValue As Integer
iValue = 13
tstValue iValue

The above works with VB 6.0, but it won’t work with VB.NET.

To support this new shift to stronger data typing, Visual Basic .NET also introduces the Option Strict statement:

Option Strict

Like its earlier predecessor, Option ExplicitOption Strict enforces explicit variable declaration:

Dim iValue As Integer

However, Option Strict enhances this data protection capability by prohibiting implicit conversions between strings and numbers, as well as limiting numeric conversions to those termed as widening conversions. A widening conversion is any that converts a smaller number, or less precise one, to a larger, more precise one, such as converting an integer to a double.

Option Strict also prohibits late-binding. Using this option, the following, while legal in Visual Basic 6.0 will generate a compiler error in .NET:

Dim obj As Object
obj.SomeMethodCall ...

As late-binding is detrimental to any wire based communication between application components, such as in a distributed or Web-based environment, you’ll want to avoid its use even within your existing Visual Basic 6.0 component development. Late-binding always requires two method calls for every call within the actual code: one to find information about the method (through automation and a process referred to as reflection), and one to invoke the method itself, necessitating two round-trips across the wire. Placing Option Strict at the top of your code module just helps to ensure that you don’t accidentally leave late-bound variables in your code.

Accessing COM/COM+ Objects Within the ASP.NET Environment–Don’t miss Shelley Powers’ first article on the differences between ASP.NET and the original ASP server environment. Shelley has also updated her book on ASP components within the Windows 2000/COM+ environment, Developing ASP Components, 2nd Edition.

All of these new techniques enforce a stricter adherence to a more strongly typed language, while still providing the option of more loosely typed conversions that do exist in many existing Visual Basic applications. This is a necessary compromise between the Visual Basic of today and the one included as part of .NET.

To ensure that your code moves cleanly into this more strongly typed environment, you can use the Option Explicitstatement now to enforce variable declarations in your current applications. Also, eliminate any narrowing conversions (converting numbers of larger precision and size to smaller data types, with the potential loss of data) in your code, and make use of explicit conversion functions when working with numbers and strings together:

StrSum = "Account is " & CStr(iValue) & " overdue"

In addition, use type libraries (included in your code module by attaching the libraries to your project) to perform early binding, not only for future compatibility, but also to improve the performance of your Visual Basic applications today.

When you open an existing VB 6.0 project in VB.NET, the upgrade wizard automatically adds the Option Strictstatement with a value of “Off” to provide for backwards compatibility in behavior. The Option Explicit statement is left as is (“off” by default).

Another .NET change to Visual Basic — and one that particularly impacts component developers — is the size of the integer data type, covered in the next section.

Integer Size

A significant data type change between the two releases of VB is the size of integer values. Starting with Visual Basic .NET, the Integer data type is equivalent to the new .NET System.Int32 data type, and is now 32-bits, and signed.

An advantage to 32-bit integers is that this size is more efficient within numeric operations than the older 16-bit integer, particularly on 32-bit operating systems, such as the current default Windows 2000 basic operating system.

Another benefit of the changed integer size is that VB is brought in line with other mainstream programming languages, such as C++, Java, and Perl. If you’ve worked with component development, particularly with components based in different languages, one of the most frustrating aspects of working with Visual Basic has been its 16-bit integer, especially when so many other languages have 32-bit integers. This is particularly apparent when accessing VB components from within PerlScript.

If you still want access to 16-bit numbers, you’ll need to use the new Short value, and use the Long data types for 64-bit values.

The upgrade wizard maintains the integrity of the VB application by converting VB integers to shorts (16-bit). If you want to ensure that your component is converted to the new .NET integer type, start using the VB 6.0 long data type for your variables and particularly your method parameters in your existing development effort.

A less significant data type change is that currency is no longer a supported data type. Instead, a new Decimal type has been provided to allow for more precision and more digits:

Dim decValue As Decimal

In Visual Basic 6.0, the Decimal data type was only available as a Variant sub-type.

Dates are also handled differently in Visual Basic .NET, and are implemented with the .NET DateTime format instead of the current Double format. To convert between the older and the new date format, Microsoft is providing routines such as ToDouble to convert the new data type to the original double value.

You can best prepare your existing code for these new data types by isolating your use of Date and Currency within your components as much as possible in order to manually migrate your code in the future if necessary.

Speaking of function parameters, another significant change within Visual Basic .NET is subroutine semantics, including a different parameter passing implementation.

Subroutine Modifications

Parameters, and how they are passed from the calling program are handled differently between VB 6.0 and VB.NET. By default in Visual Basic 6.0, all parameters are passed by reference if the ByVal keyword isn’t used. This allows the procedure to modify the variable used to pass the parameter in the calling program, which can lead to unexpected results, an example of which is:

Sub testValue(iNewValue As Integer)
   iNewValue = iNewValue + 20
End Sub


Dim iValue As Integer
iValue = 2

Call testValue(iValue)

' value is now 22 rather than 2

Parameters are passed by value as a default in Visual Basic .NET, protecting against accidental and unexpected data changes. You must explicitly use the ByRef keyword in order to pass a parameter by reference.

You can easily ensure the future compatibility of your existing code with Visual Basic .NET by using the explicit ByVal and ByRef keywords with all of your parameters in your 6.0 Visual Basic code.

The Optional parameter keyword also has different semantics in Visual Basic .NET. In 6.0 you can specify that a parameter is optional without having to provide a default value:

Sub someRoutine (Optional ByVal iValue As Integer)

In 6.0 you’d use IsMissing to check to see if the value changed. In Visual Basic .NET, you must supply a default value for all optional parameters:

Sub someRoutine (Optional ByVal iValue as Integer = 0)

To ensure smooth migration to .NET, when using Optional in your existing code, provide default values. This approach not only allows your code to move forward into .NET, it’s also a good programming practice to apply today – the use of IsMissing adds unnecessary complexity to your procedures.

Other changes with Visual Basic .NET have to do with structured data, such as arrays.

Structural Changes with Arrays

If you use arrays, you’ll find that you can no longer re-define the lower bound of an array with the Option Base statement in VB .NET:

Option Base 1

All arrays now start at zero, as arrays start in most programming languages. Again, this change is necessary for programming language interoperability, something that .NET tends to encourage (or at least, not discourage). In addition, you can’t specify a fixed array size in .NET as you could in 6.0:

Dim strValue(10) as String

Instead, you’ll use syntax similar to the following:

Dim iValue as Integer = new Integer(10) { }

This new approach allocates storage for 10 elements of the specified data type, but doesn’t fix the size of the array itself. The array can be changed through the use of the ReDim statement:

ReDim iValue(20)

To allow for maximum forward compatibility in your code, avoid the use of Option Base to reset the base value of an array. Not using this statement forces your arrays to begin with the zero boundary. The upgrade wizard will also convert arrays to being zero-based, if so instructed when the project is first opened.

Microsoft hasn’t restricted its Visual Basic changes to structural and data type changes. The use of built-in functions will also be impacted in .NET.

Built-in Functions and Namespaces

One brand new feature of Visual Basic .NET that I do want to mention in this article is the concept of namespaces. Namespaces are ways of exposing externally created components to an application, similar to importing a type library into C++ or attaching a reference to a type library in Visual Basic 6.0.

You can import a namespace into Visual Basic .NET code using the imports statement:

imports Microsoft.VisualBasic.ControlChars

With imports, you can reference members of the namespace without having to type the qualifying namespace name. Instead of:

dValue = Math.sqrt(number)

You can use:

dValue = sqrt(number)

The reason I’ve introduced the namespace concept into an article focusing on forward compatibility of VB ASP components is because many Visual Basic 6.0 built-in functions have now been defined within specific namespaces, such as the System.Math namespace, just shown.

One significant alteration to your code based on namespace use is with the String data type. Now, you can access Stringdirectly from within your code:

Dim strValue as String 

In Visual Basic.NET, String is actually defined as part of the System.String namespace. In fact, all supported data types are now a part of the System namespace, as is much of VB’s built-in functionality.

To ensure backwards compatibility, Microsoft has provided a specific namespace, Microsoft.VisualBasic.Compatibility.VB6 that you can import into your existing Visual Basic 6.0 components. This will allow applications to work within the Visual Basic .NET environment until you have time to make the actual modifications.

One final change in Visual Basic .NET I’ll look at is the impact on Properties within the new environment, and the use of Set and Let.

Property Changes

In Visual Basic 6.0, you use direct assignment when assigning scalar values but must use the Set keyword when assigning an object to a variable:

Set obj = SomeObject

In Visual Basic.NET, the infrastructure supporting properties has changed, and the Set and Get keywords are now disallowed in the programming language.

As a demonstration of this change, in the past when you’ve worked with ADO, you’ve assigned a Connection object to a variable using syntax similar to the following:

Set rs.ActiveConnection = conn

Chances are, you’ve forgotten to use the Set keyword, resulting in an assignment of the Connection object’s default property, the connection string, instead of the object itself:

rs.ActiveConnection = conn

With the above, the code will still work, a database connection is assigned to the ResultSet object, but what happens is that a second connection is created using the connection string rather than using the existing connection object.

Visual Basic .NET no longer supports the concept of default properties unless they take parameters. This is one of the design changes folks have been asking for, and one that was long overdue.

With this type of change, the accidental assignment of a default property, as described with the ADO Connection object, will no longer occur – a definite improvement within the language and the tool.

The .NET infrastructure also specifies a new approach for defining properties that provides the means to set and retrieve the property value. An example of a property within the PDC-based release of Visual Basic .NET is the following:

' Internal storage, always in degrees. 
Dim Degrees As Double = 0  
  Property Angle(ByVal Radians As Boolean) As Double 
    Angle = Degrees 
    If Radians Then Angle = Angle * 3.1415926536 / 180 
  End Get 
    ' The keyword Value stands for the value passed in. 
    Degrees = Value    
    If Radians Then Degrees = Degrees * 180 / 3.1415926536 
  End Set 
  End Property

By providing a means to define how a property is set and retrieved, the Property LetProperty Set, and Property Getstatements are no longer necessary and been removed from language support. Again, as with many of the other changes detailed in this article, the upgrade wizard will automatically correct the use of Set and Get and property management when your VB 6.0 component project is opened. Compiled components that have been wrapped via the use of TlbImp aren’t impacted by these code internal changes.


You’ve not yet had a chance to get a detailed look at all of the Visual Basic .NET changes – many are still being determined. However, you should have a better understanding of the types of changes headed your way, and how they will impact your existing VB components and component development.

Hopefully I’ve also shown that though the changes are significant, they aren’t overwhelming. In fact, there are many steps you can take now that will allow for a smooth migration of your VB component code to the new .NET architecture.

As I finished writing this article, Microsoft announced that it was restoring some of the Visual Basic 6.0 functionality it had originally pulled with the first beta release of VB.NET. This move was to ensure that VB.NET could support applications developed before the release of VB.NET.

However, if you’re creating new applications–or components–adjust your code to be in synch with VB.NET rather than depending on support for the older VB code base.


Stellar Fingerprints

When you look at the night sky from your backyard, do you sometimes think that there is no order to all of those stars out there? If the star isn’t part of a well known constellation, is it nothing more than a point of light in a sea of other points of light? Nothing that distinguishes it from any other star?

Well, this just isn’t so. In fact, stars have characteristics such as temperature, luminosity (brightness), mass, galactic location, distance to the earth, and even age — all combined forming a stellar fingerprint that uniquely identifies a specific star.

You probably already know this, but did you ever stop to wonder how we came to know these unique characteristics of a star? After all, we can’t run up and stick a thermometer in a star, or run a tape measure from the star to Earth. So, how do we find get information about stars?

Finding the distance to a star

Well, this one had me the most curious, so this is the one I’ll take first. How do we measure the distance to a specific star? If the stars are nearby, we use stellar parallax

When you move towards objects that are near you, they seem to move in relation to the objects that are located much futher than you. You might notice this when you look at signs by the side of the road in comparison to the background detail when you’re traveling in a car. You can also notice this effect when you hold a pencil in front of you and view it through one opened eye and then another (see diagram).

This same effect seems to happen to stars that are close to the Earth. If you measure the angle to a star from a fixed point on the Earth, and then measure it again from the same point when the Earth is at the opposite position in its orbit around the sun (in 6 months time), you’ll find that the two measurements form a triangle where they intersect (see U of Oregon Diagram). If you half the triangle and then take the angle of one half, you’ll get a value in arcseconds (an arcsecond is 1/360 of a degree). You can then find the distance to the star using stellar parallex:

d = 1/p

The distance to the star (in parsecs, roughly equal to 3.26 light years) is equal to the inverse of the parallex angle of the star.

A light year is the distance light travels within a year — roughly 300,000 km/s

Using this approach we’ve been able to find the distances to several stars such as Proxima Centauri at 0.772 parallax (4.22 light years); Sirius B at 0.379 parallax (8.61 light years); and Epsilon Indi at 0.276 parallax (11.82 light years).

Of course, this approach works only for stars that are relatively close to the solar system, but once you have this information, you can use the distance in other calculations — such as to find the luminosity of a star.

Finding Luminosity

A star’s brightness is a measure of its luminosity.

Luminosity is the amount of light energy emitted by the star within a second, measured in watts (joules per second).

You might think that luminosity is directly related to the distance of the object from the Earth. Well, it is, but there are other factors involved such as the mass of the star and its temperature. If star A is further from the Earth than star B, but star A is much, much brighter, it can appear more bright to us than the closer star.

Still, the distance to the star can tell us its luminosity, with a simple formula:

L = 4pid2b
In this, the Luminosity is equal to the distance squared, multiplied by the brightness, and then multiplied by 4 times pi (pi approx equal to 3.1415926...). The brightness is the apparent brightness as its measured here on Earth (or wherever the viewpoint is), through techniques such as photometry. The brightness of a star is usually described by comparing it to Sirius A, the brightest star we see from Earth (and with a brightness of 1.0).

A simplified approach to finding luminosity is to plug the Sun's brightness, distance, and luminosity into the formula and then take the ratio of the two equations. By doing this, the value of 4pi falls out of the formula:

L/Lsun = (d/dsun)2 b / bsun

Luminosity can now be found by direct comparison between the star and the Sun.

For instance, if a star has a brightness of 5.2 x 10-12 compared to the sun, and it’s distance from earth is 5.2 x 106 that of the Sun to the Earth, you would use the following to find the luminosity:

Lstar/Lsun = (5.2 x 106)2 5.2 x 10-12 = 140

The star (Regulus) has 140 times the luminosity of the Sun, but appears dimmer because of its distance. You could use this same approach with any two stars — find the ratio of the stars and then solve for the unknown value:

L1/L2 = (d1/d2)2 b1/b2

With this, if you find out that star 1 is 3 times the distance of star 2 and appears twice as bright, you can figure the luminosity without having to use a calculator: star 1 has 18 times the luminosity as star 2.

Another characteristic you can find out about a star from the light it emits is its temperature, found next.

Finding a star’s temperature

Quiz time: which is hotter, a blue star or a red star?

The answer might surprise you — the blue star is hotter. The blue color is because most of the star’s radiation is in shorter wavelengths, hence in the blue to ultraviolet range. A cooler star has a longer wavelength, in the red to infrared range.

Wien’s Law states that as a star’s temperature increases, it’s color shifts to the blue.

You can find the temperature of a star by finding the wavelength of its maximum intensity, and using this value in the Wien’s Law equation:

wavelengthmax = .0029 / T

In the equation just shown, the maximum wavelength emission is equal to a constant value (.0029) divided by the temperature. The maximum wavelength emission can be found using instruments on Earth, so this value is used to find the star’s temperature:

T = .0029 / wavelength max

If a star has a maximum wavelength of 500 nm (5 x 10-7 m), its temperature would then be about 5800 degrees kelvin:

T = 0.0029 / 5 x 10-7

This is the temperature of our own Sun. Its color is due to the fact that the maximum wavelength emission is at 500nm, putting it within the yellow color range in the visible light spectrum.

You can find the maximum wavelength emission of any star using photometry, regardless of its distance from the Earth.

Of course, once you have a star’s temperature, and its luminosity, you can then find its radius.

Finding a star’s radius

Okay, let’s recap what we’ve been able to find out about distant stars.

We’ve been able to find their distance (if close enough to use stellar parallax), as well as their luminosity (regardless of distance). We can also find a star’s maximum wavelength emission, and we’ve used this to find the star’s color as well as temperature. One thing we haven’t found, yet, is a star’s size. We have found, though, the values necessary to find the radius of the star: its luminosity and it’s temperature.

A star’s luminosity is equal to its radius, squared, multiplied by its temperature to an exponent of 4:

L = 4piR2(const)T4

The (const) value in the equation is the Stefan-Boltzmann constant, a value of 5.67 x 10-8 W m-2 K-4. (Find other constants.)

You don’t have to remember this rather computationally instensive formula if you look at it as a measure of the ratio between the star and the Sun:

L/Lsun = (R / Rsun)2 (T / Tsun)4

Re-arranging this to search for the radius, you have:

R/Rsun = (Tsun / T)2 SQRT(L / Lsun)

For instance, the star Rigel has a temperature 3 times that of the Sun, and a luminosity 64,000 times that of the Sun (one very bright star). It’s radius in comparison to the Sun’s is:

RRigel/Rsun = (1/3)2SQRT(64,000) = 27.5

Rigel has a radius about 28 times that of our Sun. As the Sun’s radius is 6.96 x 105 km, Rigel’s radius would be about 1.9 x 107 km.

An so on…

There are other things we can find out about stars, but this should give you an idea of what we know, and what we can find out about a specific star. And we didn’t even have to leave our backyards to find it.

Just Shelley

New York, New York

It isn’t Fall without trees changing color, birds flying south for the Winter, and being in New York to speak at the Internet World conference — this time as part of the Webmaster Forum.

However, this time, I stayed in New York for a few days. What an adventure.

New York Cabbies

The cab that took me from Penn Station to my hotel was driven by a gentleman from Haiti who happened to have strong religious beliefs. I know he was religious because he kept playing religious tapes, and would slam on the brakes occasionally in order to jot something down in a notebook he kept by his seat. I knew he was Haitian as he would alternate this behavior with Haitian utterances under his breath as he literally tore through that town, determined to get me to my hotel at all due speed.

I didn’t know one could drive between cars in car lanes in New York. I also didn’t know that one could drive 60MPH down Park Avenue in the middle of the day. I do now. I also received a lesson in the finer points of car horn blasting in New York.

There’s the light tatoo on the horn that says “Yo!”. There’s the more emphatic tatooing that seems to say “Yo! Stupid!”.

There’s the single tap that just lets folks know you’re in the vicinity and to watch out. Compare this with the heavy hand on the horn that will get even the most diehard New Yorker’s attention. If the horn blower is a cab driver, people seem to understand that the cabby is just letting someone know that they are invading the driver’s personal territory, whatever that may be.

I also know that pedestrians in New York don’t walk in front of the cabs without looking at the driver’s face, first. How does this driver define territory…

Cab rides are a way to experience New York, but I can’t experience a new town or city from a car — I just don’t like cars. So, I decided to walk to Central Park. On foot. No cabs.

Walking to Central Park

I started my walk on Madison Avenue — established home of advertising agencies everywhere.

Madison Avenue doesn’t have the crowds other streets do in New York, thought there are a large number of gray and black suited people, all with cellphones glued to their ears (call them New York earrings).

The buildings along the way reminded me of some of the canyons I used to explore in Arizona, except those canyons were created by water flows over a millenium of time. New York canyons are built on man’s desire to one up nature. I did notice, though, when I crossed over to Fifth Avenue that the human tide is remarkably similar to a moving river. Woe to you going against that tide of affluent and determined shoppers.

(I particularly treasure a moment when two older, well dressed women walking behind me suddenly stopped in the middle of the sidewalk and murmured “Armani” in one breath. I consider this to be a quintessential New York moment.)

The Park

Central Park is a surpise after all the opulence of the surrounding stores and the shadows cast by the towering buildings elsewhere in downtown New York.

Part of the Park was closed off for renovation, but I walked every last bit of those sections that were open. And it was a long walk.

First, let me state categorically that I cannot BELIEVE that anyone would jog in the Park after dark. The place is full of nooks and crannies, dark corners, and bushes. Charming by day, sinister by night. A horse carriage ride, yes — but not a lonely stroll through the footpaths. I’d rather play tag with a grizzley. It would be safer.

Central Park is pretty, but the trees look a little tired, and more than a bit dusty. However, the bushes and lawns are very pretty, as are the little specialized areas such as the Dairy farm.

I found an old fashioned carousel and thought about taking a ride, but dignity intruded — dammit.

My favorite sections of the Park were rocky outcroppings with bits of mica scattered about, sparkling in the noon day sun. Something like the windows at Tiffany’s and Cartier’s I passed on the way, only I could touch the rocks at Central Park and not get arrested.

I actually saw a black squirrel; I’ve not seen one of that coloration before. I don’t have my books to check to see if this is a natural variation, or a protective adaption based on New York city smog. (I know, meow, meow — but Boston is a whole lot greener.)

I walked through some bushes at one point and found a group of people silently standing around a mosaic embedded in the cement. All the mosaic had on it was the single word “imagine” — I was in Strawberry Fields, the John Lennon memorial.

One word, and I stopped dead in my tracks. One moment, with a lifetime of memories, flooding in, all because of that one word.

Back from the Park

I was getting tired at this point, so back to the hotel.

Towards the end of my walk, I stood out in front of St. Patrick’s Cathedral, an incredible edifice of which New Yorkers take considerable pride. If you’ve been to New York, you know what it’s like to come upon the Cathedral after blocks and blocks of modern glass and steel.

I have to admit that when I first looked at St. Patrick’s, I thought of how much further we would be as a people if only we expended as much energy and resources on education as we did and still do on religion.

We could have cured cancer by now, eliminated all smog and pollution, perhaps be walking on some distant planet around some distant sun.

Then I walked into St. Patrick’s. I literally stopped in the middle of the Vestibule, overwhelmed by the absolute rightness of the interior of the church. The vaulted ceilings, the stained glass windows, the slight smoky air from thousands of votive candles lit by the faithful.

It then came to me that without faith — or perhaps human spirit — we wouldn’t even try to cure cancer, or walk on the moon, much less planets surrounding distant stars. And we wouldn’t have beauty such as that.

Maybe we didn’t do so bad with our time and our resources in the past, after all.

New York, New York

My last stop on my walk was Rockerfeller Center, located a couple of blocks from the hotel. As I approached the Center, I could hear the strains of the Sinatra song, “New York, New York” filling the air. I kid you not — there had just been an ice show at the center, which finished by playing New York’s anthem song.

I couldn’t end my walking tour of New York on a better note than that.


O’Reilly P2P Presentation Proposal

Title: Smoke: An Infrastructure supporting Distributed Peer Services

Length: 60 minutes

Focus of Talk: Technical/Tutorial

Subject Matter: Infrastructure/Distributed Computation


The sale of large scale control systems — such as those used with mass transit systems or to control multi-national pipelines — often requires a marketing and engineering effort that demands the input of several different people, many of whom live in different countries and speak different languages. To assist in this effort, a project is underway to create an automatic configuration tool that allows these team members to work in a collaborative manner, regardless of each member’s locale.

Because of a lack of infrastructure for applications of this nature, the developers designed one that is based entirely within P2P-based concepts and technologies.

This infrastructure, named Smoke, is unique in that it’s based on the concept of shared distributed peer services — services that are lightweight, discrete, and transient — existing within a framework that is both open-application and cross-platform compatible.

At the presentation, the speaker will provide an overview of Smoke, as well as demonstrate a working prototype of the automatic configuration tool. To display Smoke’s open-application and cross-platform support, three variations of the configuration tool prototype will be demonstrated: one with an interface created with Mozilla’s XUL and hosted on MacOS; one accessed through Enterprise Java Beans (EJB) hosted through an Apache WebServer and WebLogic on Unix; and one accessed through Groove, another P2P infrastructure product, hosted in Windows 2000.

Smoke is an open source infrastructure, which means it can be used by any developer interested in working within a P2P distributed peer services environment.


Shelley Powers will present an open source P2P infrastructure that supports the concept of distributed peer services: services that are lightweight, discrete, and transient. A prototype large scale control system configuration tool is used to demonstrate the infrastructure. Three different variations of the prototype will be shown, to demonstrate both the open-application and cross-platform capability of the infrastructure and the tool.

Speaker: Shelley Powers

Speaker Biography:

Shelley Powers is a consultant/author with her own company, the Burning Bird Corporation, currently located in Boston, Massachusetts.

In the last several years, Shelley has worked on several distributed and Web-based applications on a variety of platforms. In addition, she has also authored or co-authored books on Dynamic HTML, JavaScript, Java, CGI, Perl, P2P, and other technologies, as well as writing for several publications including Webtechniques, MSDN Journal, Netscapeworld, and O’Reilly Network. She’s the author of O’Reilly’s Developing ASP Components, second edition. Shelley can be reached at