IDE Spelunking...

Ever wonder what the line break style is for each line in a text file? Well, there is a way to find out without opening the file in a hex-editor. If you have C#Builder, and will be in the upcoming Delphi 8 for Microsoft .NET, there is a hidden setting that will tell the editor to display special unique characters at the end of each line that will represent the style of line-break.

"HKCUSoftwareBorlandBDSx.xEditorSource OptionsxxxShow line breaks" = "True"

Where:

x.x = 1.0 for C#Builder and 2.0 for Delphi 8

xxx = Sub key for specific file types

!DANGER! WILL ROBINSON...

In previous versions of Delphi, when a user built a package, the IDE provided significant assistance in making sure the package was being built correctly by limiting what units got implicitly linked into the package. In Delphi 8 for the Microsoft .NET Framework, much of this assistance isn't being done due to the overwhelming complexity of the problem now that we've moved into the managed space. Currently, when you build a package/assembly, this is ones using the "package" keyword, not using library, which I'll comment on later, the compiler will display warnings when any unit was implicitly linked into the package. Please treat these as ERRORS. In a future release of the D4Net compiler, these warnings will change to errors.

What does this mean?

You must make sure that your "requires" clause refers to the proper Delphi assemblies and your "contains" clause explicitly lists all the units to be included in the package/assembly. What has been happening, is that folks have been blithely ignoring those errors, then proceeding to wonder why their component behaves strangely when they load it into the IDE designer. If you see any "implicitly linked unit" warnings, you need to eliminate them. For instance, if you see a warning that states Borland.Vcl.Classes was implicitly linked into your package, you forgot to add Borland.VclRtl to the "requires" clause. The same if you see Borland.Vcl.Controls implicit link warning, only you forgot Borland.Vcl.

Yes there are cases where this is legitimate, like you want to build your own specific run-time assembly with a mix of VCL units and your custom units. However, the rules regarding the use of an assembly/package such as this haven't changed... you can't build one that links into itself *any* Borland supplied .dcu/.dcuils. or to any non-Borland supplied package/assembly that does.

What's the big deal, its the same code, right?

Yes, the actual machine/IL instructions are the same, however that isn't the only thing in the assembly. There is all that metadata (this is also true for Delphi/win32) that describes certain types, such as classes, records, enums, etc... CLR is a little better at this because it will never mistake one type for another because it always internally deals with types as full assembly qualified names.
Suppose you have two assemblies, A1.dll and A2.dll. You linked into both of these assemblies, the MyComp class. To the CLR, the MyComp class name in A1.dll is actually, "MyNamespace.MyComp, A1" which, to the CLR, is a totally different type than "MyNamespace.MyComp, A2." They are not interchangeable.

But C# lets me do this.

Oh sure it does.. you keep telling yourself that. Yes, C# does allow you to create two assemblies that contain the same class, however it also warns you and will select only one of the MyComp types to use in the calling assembly/.exe. Even Delphi has always allowed you to do this. The problem comes in when you want to load those assemblies/packages into the same process/AppDomain. Consider this scenario, you have assemblies B1.dll and B2.dll, each of which uses A1.dll and A2.dll respectively. B1 and B2 contain all unique types, so all is well... not! What if B1 has a class that descends from "MyNamespace.MyComp, A1" and B2 does the same with A2? Now you have a third assembly/.exe, C, that uses A1, B1 and B2 only. It knows nothing of A2. C constructs an instance of the MyComp descendent from B2. If you did an "as" cast or and "is" test, it will *not* report that it is a MyComp descendent.

If you did the above scenario with Delphi, when it came time to link with A1, B1, and B2, you would also implicitly link with A2. When the compiler goes to link things together, it will discover that you have the same unit in A1 and A2 then fail to link. If the A1 and A2 assemblies were not Delphi written, then the compiler will still detect that it is importing two types that appear to be the same name and it will issue a warning and select one with which to link, just like C#.

So the bottom line is that a type can exist in one and only one place within a process/AppDomain. In fact this has always been the rule for Delphi/Win32 as well. So, again, I find myself saying that the rules have not changed.

The rules have not changed...

Let's hear it for Garbage Collection! Hip-Hip-Ho.... whoa there Nellie!! When it comes to VCL for .NET and Garbage Collection, the more things change, the more they stay the same..

The level of source-code compatibility between the traditional VCL/Win32 and VCL/.NET is nothing short of amazing. If you witnessed the Product Address at this year's Borland Developer Conference, you would have seen a demo where the original FishFact database demo was opened in Octane (Delphi 8 for .NET), compiled and ran with 0 (zero), count them, 0(zero) code changes. Not even the uses lists needed to change (remember WinTypes, and WinProcs? ;-).

OK, so they're compatible... What does this have to do with Garbage Collection? Well... there are some myths around GC that may get you in some serious trouble. Yes, it is true that in a GC environment, you generally don't have to worry about freeing memory. However there are a lot more types of resources than simply memory. Things like file handles, GDI handles, etc... It is easy to understand that these items are out of the reach of the GC, so you have to continue to guard your code with try..finally blocks to open/close, allocate/release, etc.. What is more subtle, though, are those "resources" that don't quite "fit" the definition of an "object."

So what other kinds of "resources" out there have to be managed in a similar fashion to those more traditional notion of a resource? I use the term "resource" loosely here in order to simply highlight the correlation to what one normally thinks of as a "resource." Suppose you have a class of objects that have specific knowledge of the container in which they live. When you create an instance of one of these object classes, they are given the container and proceed to toss themselves into that container. You now have this "bag" of objects by referencing the container. You can pick each item from the bag perform some operation on them. One suich operation that is common is to "destroy" the item. Well, since this item knows about its container, it plays nice and removes itself from the container before it self-destructs.

In the GC world, a common mistake is to simply think of "destroying" an object is simply freeing its memory. So I don't have to do that in the GC world because that will be handled for me, right? Sure it will.. eventually. But it will not automatically take care of one important resource, it's container's reference. That reference needs to be cleaned up. It is not a "resource" onto which the item itself holds, but is a resource nonetheless. When you look at the declaration of the object, you won't find a reference to this resource... oh wait yes you do... It is the reference to the container itself. It is through this reference that the "resource" lives.

So if you don't "destroy" an object, how do you make it release its references? In .NET, there is a simple pattern that is followed. An object that needs to do immediate resource cleanup, should implement the IDisposable interface. It has one method called procedure Dispose; (or for you that prefer a more "curly" world void Dispose();). Now when you want to "destroy" an item in the container, you cast the item to IDisposable and call the Dispose method. In the Dispose method it just performs the nessesary steps to remove itself from the container.

Sure, you could manually remove the item from the container yourself and forgo the IDisposable riggamarole, but what if you hand the item off to someone that has no specific knowledge of the particular container instance in which the object is currently living? This is why the IDisposable pattern is important.

So let's bring all this around now to Delphi 8 for .NET and its view of the world. All this IDisposable stuff seems tedious and would require some massive changes to my code to play nicely in .NET. This is where Delphi has realized some of the benefit of arriving a little later to the party. Delphi introduces an interesting language construct called "class helpers." There could be a whole tome written about the subject of "class helpers", but suffice it to say, they have given the Delphi programmer a familiar world in which to work. All that code you have written in which you dutifully have implemented your destructors to properly clean up after yourself, release resources, and generally keep your house in order can now continue to live on..and serve a real purpose beyond simply releasing memory. Releasing memory is no longer the responsibility of the lowly Destroy destructor. It now is a cue to the Delphi compiler that you want it to implement the IDisposable pattern for you. Your object now implicitly implements IDisposable and the Dispose method maps to your Destroy destructor. It even takes care of guarding your destructor from being called more than once by implementing the pattern of setting a compiler generated instance variable to true the first time through the Destroy destructor and exits immediately on all subsequent calls. To the world outside Delphi, your objects simply appear to implement the IDisposable pattern. The really cool thing though, is that all objects that come in from outside Delphi (remember all objects in .NET descend from System.Object, which is not Delphi's System.TObject. In the CLR world, it is the other way around. Borland.Delphi.System.TObject = System.Object) "appear" to have a non-virtual method called Free (thank you class helpers). If you are a seasoned Delphi developer, you know that in order to maintain proper "exception safety" you never call the Destroy destructor directly. This is because the Free method would check to make sure Self (or this) is non-nil before calling Destroy. In .NET it continues to do this as well, but now it checks if Self implements IDisposable and then calls Dispose if it does. This is why you can call MyHashTable.Free. Through the magic of class helpers, the Free method appears to be a method of HashTable.

So now all your nicely done try...finally code continues to serve a purpose, in fact is remains critical to the proper operation of VCL code. For instance, a TComponent derivitive takes an Owner parameter in its constructor. It then proceeds to add itself to the Owner's list of Owned Components. So, when you call Free on the component, the expectation is that that component is removed from the Owner's list immediately. These semantics are now preserved.

Garbage collection certainly takes away certain programming chores, but it is not a panacea. The more you understand the environment in into which you are moving, the better you'll be able to migrate your existing code. So the upsot of all this is that you don't have to change nearly as much code as I'm sure you originally thought nor should you.

Up periscope...

Just a quick note here... For those two or three folks that seem to be gluttons for punishment and actually read this jumbled mess of random thoughts... I hope to be back in the blog saddle within the next few weeks. I need to make good on the promise that I'd present some of the material I had planned on preseting in my "IDE Spelunking" BorCon talk that was canceled.

Aftermath

Now that the 2003 BorCon is behind us, we are now "kickin' it up a notch" for that final drive to release. This is mainly why the blogs have been coming less frequently... that whole "work" thing keeps cutting into my blog time ;-)... Also we're at that stage where the days are sort of blending together...

It seems the rainy season here in Santa Cruz, County, CA has started in earnest. While it is sunny today, the past week was filled with dark overcast foggy skies. That certainly makes it easier to keep ones head down and concentrate on completing the release.

BorCon talk

I just finished my one talk I was still giving at BorCon and am now back in the office... It was a small crowd, but it always is since Open ToolsAPI stuff isn't a huge draw. I got to present some interesting things, like we plan on publishing a Delphi/C#Builder integration package to registered users and partners to allow them to move thier existing Delphi and/or C#Builder IDE plug-ins over from Delphi 7.

Stay tuned.

Avalon: Yes, the Picture's Changing

Avalon: Yes, the Picture's Changing

Here's a response that I posted to the above article:

I can see everyone rolling their eyes at the loony that is about to make this statement.

The movement of the declarative "InitializeComponents()" code to another more suitable "language" is nothing new, nor earth-shattering. Now comes the controversial part. Take a look at Borland Delphi... "Oh, I've heard of that" No, it is *not* just that "database" tool. It is a full featured, powerful object-oriented, component-based, compiled-to-native-code, development environment.

The Visual Component Library (VCL) that is included with Delphi uses a predecessor to Avalon's XAML. By using a text or binary declarative "language", the form construction is taken out of the code. This "script" is attached to the executable as a resource. It can also be easily localized by providing an alternative script.

Avalon is clearly an evolutionary step along this same path, but I would certainly *not* characterize it as "revolutionary."

Yes, I work for Borland. Yes, I'm one of the original developers that designed and built Delphi. Delphi was launched on February 14, 1995 at the Software Development West conference in silicon valley.

If you look closely, and resist the urge to revise history, you'll see that one of the primary architects behind .NET is Anders Hejlsberg... who was one of the original architects behind Delphi. Anders left Borland and helped produce J++ and WFC, then eventually C# and .NET. If you compare WinForms, WFC, nay Delphi's VCL, the similarities are... let's just say, striking.

What I find interesting and, to be honest, somewhat frustrating, are the reactions when I state that "Delphi's been doing this since 1995." I can see them rolling their eyes, as if to say, "There's another of those Delphi crackpots who thinks they actually innovated something."

In actual fact, we at Borland are extremely excited about the technologies that are coming out of Redmond.

In fact, if you happen to *be* a Delphi programmer you need to keep your eye on the "Octane" project.. and if at all possible, attend the Borland Conference in San Jose, CA starting this weekend (Nov. 1, 2003).

So I guess it *is* true that imitation is the highest form of flattery.

Allen Bauer.
Borland Software Corporation.
RAD .NET IDE Architect.

Editor pair highlighting

Since one of my BorCon talks has been canceled, I will begin to post some of the content that was planned here. To get things started, here's one item that applies to C#Builder (and the upcoming Delphi 8, codenamed "Octane").

Modifying which character pairs the IDE highlights:

Insert standard disclaimer concerning editing your registry, here

Open RegEdit and go to the following key:

HKCUSoftwareBorlandBDS1.0EditorSource OptionsBorland.EditOptions.XXXXPair Table

Under the above key there are string entries formatted as comma separated values, for instance the "(* *)" pair in the "Borland.EditOptions.PascalPair Table" key is represented as:

0,1,2,(*,*)

The meanings of these values are, in order:

Nestable = 0 - No, 1 - Yes, 2 - Maybe
ImpliedDir = 0 - No, 1 - Yes
CharCount = 1 or 2 only
Starting string = 1 or 2 char string
Ending string = 1 or 2 char string

So to create non-nestable, implied direction pair for, say <% and %> it would look like this:

0,1,2,<%,%>

So if you don't want to highlight the quote characters since they have no implied direction and will often highlight strangely, delete the 0,0,1,',' and 0,0,1,"," entries and those pairs won't display as match characters. Note that this will also disable the Ctrl-Q+[ and Ctrl-Q+] functionality for those characters.

Talks canceled

Due to product scheduling constraints, one of my BorCon talks has been cancelled. The "IDE Spelunking" talk will not take place on Tuesday, November 4 as planned. The Open Tools API talk is also in danger of being canceled as well. This stinks... I'll also not going to be able to be there very much either... Even though it is less than 30 minutes from Borland.

Borland at this year's Microsoft PDC

Marco Russo - Borland at PDC

It seems that some folks are certainly noticing the conspicuous placement of Borland at this year's Microsoft PDC. And, since BorCon is after MS' PDC, there'll be a lot of continued buzz... You don't want to miss it.

Managed code gotcha's...

.NET Framework Security: Using Win32 and Other Libraries (Working with C#)

Just learned a little lesson when working with managed code and P/Invoke. If you are providing a delegate as a callback to a P/Invoke'd Windows API function, make absolutely sure you hold a reference to that delegate for as long as that Windows API needs to call it... ;-) Since the CLR doesn't track references to things that travel off into the unmanaged nether-world, it will blithely garbage collect your delegate. This promptly hangs your unsuspecting API out to dry (think RegisterClass and CreateWindowEx). The absolutely insidious thing about all this is that it will work.. for a while. So take my advice, the oven is hot; wear your oven mitts...

For all the time I've spent working with managed code, COM-interop, and P/Invoke, you'd think I'd know this stuff... But then again, I'm no Don Box, ChrisAn, or Lutz Roeder, et. al.... they've had the luxury of being exposed to this for a few more years ;-) Eventually, this stuff will seep through the several inches of solid rock and touch some grey-matter someplace...

Ryan Dawson on Longhorn (in hot water...)

Ryan Dawson on Longhorn

Whoops... somebody raised a few eyebrows at MS ;-)... Ryan's previous post has been expunged and he doesn't even work for MS. I still have a cached copy though.

Ryan Dawson on Longhorn

Ryan Dawson on Longhorn

All I can say is... wow... So, Ryan, who peed in your Wheaties? The thing is I agree with a lot of what he said, but you can catch more flies with honey than vinegar.

BorCon prep

Yes, it's been a few days since my last entry.. well I've been up to my eyeballs trying to complete some deliveries. We have got to have a reasonably stable build of stuff available for all those demos at this years' BorCon. This also has to be done before I can begin to prepare for my talks, which is going to be like cramming the night before a test.

I did get my final schedule for my talks. The info is here.

Some photos from BorCon 2002

Here's some photos I took last year in Anaheim, California at BorCon 2002. This is while at Disney's California Adventure for the Tuesday evening event. You can see me in the foreground sitting next to Chris Anderson with Eddie Churchill in the front. I presume he's begging for more information about .NET ;-). There's also a photo of Danny Thorpe with ChrisAn deep in discussion.

Maybe this will trigger some of ChrisAn's visual memory...

Click the images for for full size.

BorCon adjustments

Time is certainly a limited commodity. With BorCon now only 14 days away... I've not been able to spend any appreciable time preparing for my talks. So with that, I've been able to convince Eddie Churchill, take over one of my talks. So I'm now down to two talks... I think this will work out. The good thing about this is that when I notified Christine Ellis about the change, we just happen to beat the printing of the conference catalogs by only a day, so the catalogs will be correct.

RSS Changes

Some other folks have mentioned that they are having issues with my RSS feed... so I did some changes based on their suggestions. This whole RSS/RDF standards thing is a mess right now. That's the good thing about standards... there are so many to choose from.

Impromptu QA

Thanks to John Kaster and Roy Nelson for providing some impromptu QA on my RSS feed hack. Apparently I was missing a " " (space) between the "1.0" and ?> in the <?xml version="1.0" ?> header. Should be fixed now. I don't see why this space should be significant, but there are some new aggregators and XML validators that complain. I know that NewsGator seems to be OK without the space. It's on points like this that I find the W3C specs to be lacking in clarity.

RSS Feed

OK, I figured out how to get an RSS feed up and going... You can now subscribe to my RSS feed here. It's not perfect, since it is somewhat of a hack. I simply added an HTML comment to my template that contains the RSS XML skeleton. Then, using their own template tags, Blogger will fill in this XML skeleton when it is published to the server. Finally, on the server, which is a Linux box, I wrote a Perl script (yea, yea, I should have used Kylix...) to scrape the HTML file and extract the rss xml data and write it to rss.xml. This script is setup as a cron process which runs every five minutes. If it detects that the html file date is newer than the rss.xml file, it will regenerate that file.

As far as not using Kylix... well I didn't have a Linux box up and running with Kylix installed at the time and this was sort-of a late-night, "let's see if this works" project...

It's Official: No Longhorn Until 2006

My take on this is that this certainly gives developers more time to get up to speed on the new platform... not all the doom-and-gloom portrayed by this article.

So, all you Delphi devlopers out there, you definately don't want to miss out on BorCon this year. Since it is after Microsoft's PDC, we are going to have several folks from MS giving talks about some of their future stuff (yes, it will definately be .NET/CLR related)... hopefully we'll get a synopsis of what will be presented at PDC.

Class references and virtual constructors

What are some of the things that makes Delphi unique? One thing that Delphi provides is virtual constructors. So how do you make a virtual call to a constructor when, by definition, you don't have an instance? This is accomplished by using a one of the other somewhat unique Delphi constructs, the class reference. A class reference variable holds, not a class instance, but a class type. They also follow the same assignment compatibility rules that a class type variable does.

So what is this good for? What if you didn't know what class to construct at compile-time? Well, class references and virtual constructors to the rescue. So you can now have a hierarchy of classes where you can decide at run-time which classes to construct and use.

type
  TComponent = class
    constructor Create; virtual;
  end;

  TComponentClass = class of TComponent;

...

  TMyComponent = class(TComponent)
    constructor Create; override;
  end;

  TMyOtherComponent = class(TComponent);
    constructor Create; override;
  end;

function CreateComponent(AComponentRef: TComponentClass): TComponent;
begin
  Result := AComponentRef.Create;
end;

procedure CreateComponents;
var
  AComponent: TComponent;
  AnotherComponent: TComponent;
begin
  AComponent := CreateComponent(TMyComponent);
  AnotherComponent := CreateComponent(TMyOtherComponent);
end; 

In the above example, the function CreateComponent will create any component that is of type TComponent or any descendant thereof. TComponent is declared to have a virtual constructor. By passing in a specific class reference type into CreateComponent, any component descendant can be created.

Still not convinced? Well this is exactly how the Delphi form designer functions. When you register your components into the IDE, you are passing a class reference. This is then stored internally in a class reference variable associated with a particular tool palette item. When the user selects the palette item and clicks on the surface of the form designer, that class reference is passed into the designer where a component instance is constructed by calling the virtual constructor through that class reference.

There you have it. Hopefully you can see the power and simplicity of using virtual constructors and class references.

Chris Anderson found me..

Seems Chris Anderson found me... What I find interesting about his blog is the amount of personal information he shares. We all can get to know him quite well, yet we are all anonymous to him. I've personally met Chris several times and can say that he's dedicated and passionate about his work. He's also extremely talented and I count it an honor to have met him. He and I also have another thing in common; we've both worked side-by-side with one of my all-time, most respected engineers, Anders Hejlsberg.

I've always believed that in order for one to grow personally in any area, technically, socially, spiritually, etc.., one should surround themselves with folks that they respect and admire in that area. Anders Hejlsberg was certainly a person of this caliber, both as an engineer and as a person. I also know that Anders only works closely with top notch folks, so it certainly is safe to assume that Chris "has got it goin' on."

I hope that wasn't too sappy for you Chris... ;-)

Generics in the .NET CLR

The generics are coming, the generics are coming... The next release of the .NET platform/framework will contain support for generics. If you are going to be doing any kind of .NET programming you should really bone-up on this stuff. These are definately not your father's C++ templates. Generics for cross-language use is going to be really cool...

Truth is sometimes stranger than fiction

CNN.com - Schwarzenegger wins, Davis concedes - Oct. 8, 2003

This is just plain weird. Ah-nold takes the gubernatorial recall race. Whodda thunk it? Well... I suppose that even if he doesn't do anything while in office, that is better than making an even bigger mess. And who knows maybe he'll actually fix something. One thing is certain though, it has certainly woke up the California voters. There was a record showing at the polls. I know I had to actually wait for a parking spot at my polling place. Normally there are only about two or three other voters while I am there. This time there was about 8 or 9.

Poetic Justice

http://www.miami.com/mld/miamiherald/living/columnists/dave_barry/6934584.htm

There *is* such a thing as "poetic justice" in this world....

I implemented my own "do-not-call" list several years ago. Many phone companies offer what is called "Privacy Manager." This little service works with the callerID service by automatically blocking callers that refuse to present their callerID information and diverting them to a special message. In this message they can elect to reveal their callerID number, or identify themselves verbally and wait for the "Privacy Manager" to contact us on their behalf. The interesting thing about this service is that since most telemarketers don't present their CallerID info, they are hit with this first line of defense. Also, since telemarketers work on volume they are just as impatient to wait the minute or so it takes to actually by-pass all those phone menus and messages as you and I would be, so they just hang up and I never even know they called. For those few diligent telemarketers that actually take the time to wrestle with the inconvenience of the privacy manager, I figure it must be important so I'll answer. Oh and this also blocks calls from folks not covered by the do-not-call list.

Boring drivel

I hope I'm at least as boring as this guy feels about the .NET bloggers.... If I were spoofed, at least I'd know someone was listening ;-)..

/dev/null

Maybe I'll start posting information on IOTANotifier..

Crunch time...

It's crunch time here for the Delphi/C#Builder team. With BorCon fast approaching and schedules needing to be met, it certainly makes life here interesting. At this year's BorCon, Borland will be celebrating it's 20th anniversary. You don't want to miss it. There's going to be a blow-out celebration on Sunday November 2nd at the San Jose McEnery Convention Center. For all you Delphi/C#Builder customers out there, the "Meet the team" session on Monday evening November 3rd, from 8-10pm is an event you have got to attend. Since BorCon is only about 30 miles from the Borland Campus in Scotts Valley, you can be sure that the entire team will be there.

Blogroll

Today I'm going to give you some links to other blogs that I read. Since I work on the C#Builder and Delphi for .NET IDE, it is only fitting that I also keep tabs on some of the movers and shakers of the .NET world. Some of these folks seem to always be talking...

The start of my blogroll:

simplegeek - Chris Anderson
Don Box's Spoutlet
Scott Watermasysk
The Frontier - Lutz Roeder
Marquee de Sells - Chris Sells

I'm keeping the list small since I can't really spend my entire day reading everybody's blog... no matter how interesting.

Borcon

BorCON - That term strikes fear in the hearts of many here at Borland... Mainly because those of us that have agreed to do talks are now starting to feel the pressure to finalize their talks... or in many cases, ahem.. to start them. October is shaping up to be an interesting month for many of my colleagues and I. For those two or three folks that actually read this drivel, I'll be giving three talks, 2110, 2172ab and 3130 at BorCON this year. Also since it is being held in San Jose, CA Convention Center which is only about 20 minutes from Borland in Scotts Valley, the "Meet the Team" session promises to be quite interesting. We plan on having as many of those on the Delphi/C#Builder dev team there. This session is in the evening on Monday, November 3 starting at 8pm.

Maybe I did miss NewGator after all... I just went ahead and registered it... or maybe it was simply to stop it from nagging me that the trial has expired [-)...

MP3s are not the devil

Art Watch - September 14, 2003 - MP3s Are Not the Devil - Part 2 - The Ornery American

Part 2 of a very well thought-out and convincing article... Part 1 is here.

Well... my bad. It turns out that Windows Mobile 2003 does exactly what I want with respect to multiple WiFi networks. I just needed to download the updated WiFi driver for my card... to bad the card is now starting to fail.

Pocket PC 2003

This past weekend I finally received the Windows Pocket PC 2003 upgrade for my Dell Axim. It was somewhat painful to perform the upgrade. First of all, the backup format was changed between PPC2002 and PPC2003 so you could not simply use the backup utility to retain all the information, so all the data had to be manually backed up. Then it was a little flakey during the install. It lost the connection with the computer once and had to be restarted, which made me rather nervous since this can cause the flash ROM to be half-burned rendering the device unusable... fortunately it only died during the copying of the new image to the device before it actually started the burn process. After about 20 minutes, it finally completed the upgrade.

The first thing you'll notice is there is very little visibly changed. It does have a little better connectivity management but what I'm really looking for is a utility that will automatically recognize and log-on to all the various WiFi networks I use.

<rant state="on">Right now I have to keep a set of registry files and a registry editor on the device. I place these files in a folder off the Start menu and then when I "lanch" the reg file, it launches the registry editor and imports the file. This was tedious to setup since I had to manually enter the WiFi settings in the card setup utility, open the registry editor and save the keys. This had to be done for each WiFi network which I use. Windows already has the support for this roaming capability for notebooks so you'd think that a mobile Pocket PC would do the same. Seems more likely that you'd carry around the Pocket PC to more WiFi networks than even a notebook. </rant state="off">

We here on the Delphi/C#Builder team firmly believe in the term "eating your own dogfood." (I really hate that term, BTW). With that we've moved from an internally developed source-code archiving tool to StarTeam. Our hope is that by providing in-house real-world usage we can help improve the product. There are several of us on the team that have very strong opinions about how a source-code management system should work. This is from years of having to struggle with all the half products out there and also from breaking down an developing our own internal system (let's just say that I know a few things about version-control...).

This transition has not been without its trials... however so far the added benefits of StarTeam are certainly out weighing the pain we are incurring during this transition. I must say that I am certainly impressed with the versatility and configurability of StarTeam. Most of the pain we are incurring is just having to train folks in a few new processes. This is sorta like trying to turn an oceanliner... you have to plan your move in advance and communicate to all involved.

One of the areas in which StarTeam excels in, is in workflow control. StarTeam integrates bug tracking, requirements management, tasks, and developer discussions. These are collectively known as a "process item". By controlling how a "process item" transitions through its various states, you can better insure that things won't slip through the cracks. There's also this really interest "nag" feature in the form in notifications. You can configure an item, such as a Change Request, to notify the responsible developer or manager if the item sits in a certain state for too long. Also, it can be configured such that when a new item is created without an assigned "owner" or responsible person, it will notify a list of users asking each one to accept or decline responsibility. All this is done via email with links to a special web-server on the hosting server.

This is just a small piece of what this system can do for medium to large teams. We also work with many other dev teams located throughout the globe and having a common source-code system has been a clear advantage.

This certainly sounds like a shameless plug... well it is and it isn't... This blog was suppose to include little tidbits about some of the things that happen in the Delphi/C#Builder team. So I figured some insight about what other tools we use would be interesting.

Canon EOS 300D / Digital Rebel Review: 1. Introduction: Digital Photography Review

Canon EOS 300D / Digital Rebel Review: 1. Introduction: Digital Photography Review

A coworker just stopped by and told me about the new Canon EOS 300D. I've had my eye on the EOS 10D for a while... now I might have to rethink that. This thing is essentially a 10D with fewer "pro" level features... all for $899! vs. $1499 for the 10D.

Art Watch - September 7, 2003 - MP3s Are Not the Devil - The Ornery American

Orson Scott Card has this very reasonable retort to all the shenanigans that the RIAA is pulling as of late. Couldn't have said it better myself...

So far I haven't really missed using NewsGator for reading news groups now that it has expired... However I do kinda miss the RSS feeds from other bloggers out there... Looks like I might have to go ahead and register it...

Oh, BTW.. I was all excited about the device coming with Windows Mobile 2003... well it doesn't. I obviously mis-read the offer... no big deal. It did come with some dev tools from ViewSonic and also the Compact Framework. This was on a separate CD install and the CF was not pre-installed on the device. All the marketing and offer collateral certain gave the impression that it would be pre-installed... but hey it was free so I'm not about to complain.

OK, after playing with the ViewSonic V37 Pocket PC and comparing it to my Dell Axm X5.

My first impressions of the V37 were largely positive. It is certainly thinner and lighter than the X5. The screen is just a smidgen larger, but you can only see the difference when placed directly next to one another. The brightness and contrast of the display was very good and virtually identical to the X5. It has a reasonable feel in the hand, however it does feel a little more delicate or flimsy. The Axim has rubber grips down the side that give it a solid, slip-free feel in the hand. If my hands are a little dry and slick, the V37 feels like it might be able to slip from my hand.

The only standard expansion slot is an SD slot in the middle of the top of the device. It does support SDIO which is just now an emerging standard for using an SD slot for things other than memory, much the same way that Compact Flash slots are now used for a myriad of non-memory devices. They included some collateral in the box that offered an 802.11b SDIO card. However when I went to their site it is still not available. What is taking so long to get the SDIO devices onto the market? Wireless SDIO cards were announced almost a year ago to be shipping Q1 of this year.

I transfered my 128 Meg SD card from the Axim to the V37 and it immediately recognized it and was able to read it just fine (I would hope so...). I have some programs on the SD card and so I ran them. They seemed to load faster on the V37 than they do on the X5. Probably because the SD slot is a newer design and uses the full 4-bit transfer, although I don't have any hard facts on this.

The V37 does't have a user-replaceable battery like the Axim so you are probably stuck with sending the device to a repair center for a battery replacement. However battery technology these days is getting better all the time so I imagine that the built-in battery will give several years of useful life. I also have not run any battery run-down tests so I can't give any details on the battery life.

The docking stand is fairly small and lightweight. This is both good and bad. The connector on the docking stand is fairly tight so you have to hold the base with one hand and undock the device with the other. It is also for this reason, the docking stand is more portable so you can more easily take it with you. The Axim docking stand is a beast. It is very heavy and allows one-handed un-docking. It also has a slot in the back to allow you to keep a second battery charging which contribute to the weight.

Since the V37 and the Axim both use a 400Mhz XScale, I can't say that one performs any faster than the other. They seem to be on par with each other.

Pros:

Thinner and lighter

Screen is slightly larger but is about the same brightness and contrast as the Axim

SD slot that supports SDIO

Seems to read from the SD card faster than the X5

Unique telescoping stylus

More portable docking stand

Cons:

Less substantial feel in the hand. More flimsy feeling.

SD only. Limited expandability due to slow industry adoption of SDIO expansion cards

No user-replacable battery

Less sylish. More boxey.

Headphone jack is on the side rather than the top (can't listen to audio with it still in the slip-cover case)

Requires two hands to undock the device

ViewSonic: Products: Pocket PC: Pocket PC V37

WooHoo... my free ViewSonic V37 Pocket PC just arrived... This was a special offer from MS for VS.NET customers... well I have an MSDN subscription and it qualifies. It is certainly a little thinner than my Dell Axim, but then it doesn't have a CF type II slot, just an SD slot. It does have Pocket PC 2003 with the .NET Compact Framework pre-installed. Which is interesting since I still have not received my Pocket PC 2003 upgrade from Dell for the Axim... I ordered it back in June... Grrr.... Well at least I have a new toy to play with this weekend...

Now before all you astute observing folks get all excited... This does not mean anything regarding any future Borland product releases... it is just a new toy, plain and simple.

In the past, there has been some misunderstandings about what Delphi Packages are and how they are used and/or managed. I recently posted this to an unnamed newsgroup that seemed generally useful. It has been edited for content so that any unreleased information has been removed... however the gist of it is still there.

Since we are working on the next releast of Delphi that will target the Microsoft .NET platform, assemblies are going to continue this level of confusion in spades. Sometimes folks have trouble visualizing how packages (and assemblies) inter-relate. hopefully this will shed a little light on how the dependencies work. This is valid for both Delphi/Win32/Linux and Delphi for .NET. Hopefully this will answer the common question of "why can't I just link with this one package and have the rest of the units linked into my app?"

Think of an assembly or package as a tree branch (this analogy will break down at a certain point but the visual is still valid). Now that branch has other branches attached to it as well. You can take any of the "sub-branches" and break them off and they still form a complete independent branch. However the original branch is no longer complete. Now if you sort-of reverse how you view the dependencies... there is always a "root" package. This "root" package will contain the Delphi System unit. Since package rules say that a certain unit can only exist in one and only one package, all other packages above the root must link with that same root package. Just like a tree can't have a branch that doesn't eventually flow back to the root. Now at any point above this "root" you can move units between packages almost at will, but if you view each package above the "root" as being its own "root" then the rules simply repeat. This is all the same with assemblies, however there is a bit of an anomaly with mscorlib and System.Xml.. they reference each-other. The "root" in .NET is mscorlib. In a sense with .NET your apps will always link with at least one "package" or "assembly."

So when you pick a package or assembly with which to link your application, you will implicitly link with all the packages with which that package links all the way down to the Delphi System unit (or in .NET, down to mscorlib). By carefully choosing a point in this dependency tree, you can control what units will be linked into your application and which ones will remain in packages.

This is the first post after actually telling folks that this silliness exists.. Welcome to the mundane, marginally useful world of blogs...

This blog is now live... and on a date I know I'll remember...

Please do take a moment to remember and reflect on the many lives lost on that fateful day two years ago...

Well.. my trial of NewGator will expire day after tomorrow.. So far I like it for gathering RSS feeds (I'd like to get an RSS feed for this blog so I can find out what I have to say...). The nntp connector leaves me a little wanting. I think the problem is that Outlook doesn't support real threading of conversations like Outlook Express does. I'll let it expire and see if I have any withdrawal.

Eventually Borland will have it's own blogging engine and we can then use that instead of going to an outside source.. It will also allow feedback comments.. hmmm.. On second thought I don't know if I like that idea. I'd rather be blissfully ignorant of what you folks really think of this mess...

Well... I just downloaded and installed NewsGator for MS Outlook (not Outlook Express). I must say that this is a very nice little utility. I'm planning on using the 14 day trial to really form an opinion, but so far so good. The other cool thing about it is that is is written for the .NET platform.

OK... I finally got this thing publishing to the server. Now all I need to do is to "publish" its existence...

Allen Bauer.

Hello,

This is my first official "blog" entry. Since this seems to be all the rage these days, I couldn't let another fad pass me by. So here it goes.

First of all, my name is, Allen Bauer. I am the lead Architect for the Delphi/C#Builder IDE. I am responsible for making sure that all the excellent technologies the other team members produce play nicely with one another inside the IDE. I also design and maintain the Open Tools API, which is used by many third-parties to integrate their value-added solutions into the Borland IDE. Recently I've been working hard at redesigning the IDE to support multiple project personalities. This moves the IDE into more of a framework into which a product is placed, rather than being a monolithic jumble of code that is taylored to each and every product.

The first version of this new architecture shipped with Borland's newest member of the RAD products, C#Builder. This is an IDE that supports building native .NET applications using the Microsoft C# language. It supports both WinForms and WebForms by integrating those specific designers.

In the future, as things progress, I'll post some of my entries that may provide some insight into some of the inner workings of the Delphi/C#Builder team...

Allen Bauer.