It seems like just six months ago that I was reviewing the latest Delphi from the new CodeGear and here I find myself again cracking open a new version. But it's not the onset of anterograde amnesia, just CodeGear's separation of native Win32 development from .NET development.

Just to make things more confusing, I'm actually running CodeGear Rad Studio (CGRS) Architect, which includes upgraded Win32 development tools. What's cool about this is that while CodeGear has separated the two products for those that want one or the other, they're clearly aggressively developing both, and the pure Win32 developers can upgrade their tools.

Besides the Delphi Win32 and Delphi .NET, Architect also includes a separate facet (meaning you can run it independently) for C++ Builder, and tucked in to the .NET facet are the C#-based projects. From a reviewer's perspective, it can be a bit muddled, but in actual practice—when you're actually doing a particular project and not just nosing around in every corner to see what's there—the only problem I had was sometimes pulling up .NET-only when I wanted Win32-only and vice-versa. (The solution being to use the full version, which seems to load more quickly than some earlier versions of Delphi.)

For this review I'll be focusing on the Delphi .NET features first and pointing out where they do and don't overlap with the Win32 native environment. I won't go deeply into the C# and C++ aspects of RAD Studio.

Basics

The .NET offerings include all the usual suspects: ASP.NET web applications, libraries and, now, AJAX-Enabled web applications. One entry that might make you do a double-take is the .NET VCL for the Web applications. But of course, a .NET app doesn't need to be an Internet application, and VCL for the Web (formerly Intraweb) is its own creature. Still, it sort of makes my head spin, not because it's a technically challenging concept, but because it seems like an odd thing to do.

On the language front, generics have finally made their way into Object Pascal which, initially, caused me some concern. Honestly, when I think of generics, I'm reminded of Alan Kay's comment that he'd never met a static typing system that wasn't more trouble than it's worth. Nonetheless, it's very seductive. I deal with a lot of very particular data-types, like fixed-length character fields and packed decimals and other custom data types, and generics give me an elegant approach to handling them.

I tend to do most of my non-web development in native Win32, and generics have tempted me into using .NET in situations I wouldn't normally (like a console app). For those of you who are Win32 purists, CodeGear is planning to implement them there as well.

Meanwhile, the WinForms support is gone from Delphi. I think that's probably a good thing, but it does seem to mean that Delphi.NET binaries are going to be bigger than other .NET binaries—and even bigger than Delphi native EXEs.

WinForm's absence sort of makes you wonder about the C# support, as well. The default C# app builds a WinForm, but you want to use it, you'll have to code the components in by hand (old school!).

ECO

By far the most compelling aspect of Delphi .NET for me is Enterprise Core Objects (ECO). Persistence and database independence, to say nothing of a design that basically forces presentation to be separate from the model—I tend to believe that this is the way that industry will head.

I've only used it for “toy” applications to date, but the power of the toy application shouldn't be underestimated. If you can quickly throw together something using Delphi and Eco instead of Access, you at least have a good growth path when that toy morphs into a real project over time. (Also, doing toy projects can get one comfortable in a new paradigm, and using UML and other design tools to generate code is an area many are not comfortable in.)

On the bad side, ECO is where I hit the most instability and “huh?” moments in the IDE. It never brought the IDE down for me but it did generate exceptions and leave it in a state where I didn't trust it. It also felt far more sluggish than the rest of the IDE.

Blackfish SQL

The other really big item in CGRS is the “new” database engine, Blackfish SQL. Blackfish isn't really new—exactly—it's a new port of JDataStore done in C# and apparently developed in parallel with the Java version. What this means, apparently, is another bridge between .NET and the Java VM. (The client code for the Pascal version is similarly maintained in Pascal. Check it out!

You can deploy Blackfish as a windows service or standalone app, and you can even embed it in to your executable, a nice option. There are license restrictions on the C/S version that would make me hesitant to roll that out unless I needed the interoperability feature. (You can, of course, buy more licenses, but that always seems to bite me when I least expect it.)

While it works for both native and .NET programs, .NET gets the advantage here: Because Blackfish is managed code, you can actually debug stored procedures in the CGRS debugger! How cool is that?

Summary

I try to live with the products I review for at least a month after they're out of beta so that I can give a fair accounting of things like stability and an appraisal which (while necessarily subjective) at least highlights the biggest icebergs that might sink your coding cruise ship.

But even so, there are things that I don't cover or things that I just plain miss. After praising Delphi 2007 for Win32's stability here in my DevSource review, it crashed on me the following day for the first time. (Fortunately, that was a one-time fluke.) Delphi 2007 included an integrated testing unit which I love but somehow edited out when I was reviewing it. (CGRS includes the same unit, by the way.)

A strange thing about CGRS is that I'd love to review a feature that's NOT in there: Virtual Folders. If you check out “virtual folders” in the Delphi help, you'll see that they're a way to organize the files in your larger projects that only impacts how you see them, not where they actually reside on disk. I got addicted to this sort of thing when they were called “Workspaces” under OS/2. After looking under every menu and facet of Delphi I could find, I discovered they only exist in the C++ facet.

While it seems like a minor thing, it's partly representative of the CGRS feel for me. There are a bunch of good ideas and a strong sense of direction, and thankfully the stability and speed issues of earlier version have been resolved, but there is a kind of sprawl and incompleteness to the thing.

One reason I think it's good that WinForms has been removed is that I'm not sure that the sprawl it engendered was worth its contributions to Delphi. But the C# facet needs also to be shaped up or shipped out.

That said, I'm pleased with what this new version brings to .NET and to Win32, and can recommend it.