dxRAM - Richard Morris' DevExpress blog

1001 DevExpress Tales

2009-11-17T15:51:00Z

We're quite excited about the completion of the first DevExpress Book "Professional DevExpress ASP.NET Controls", and the timing couldn't be better as we took delivery of the first 2 palette loads right as we were putting together boxes of DevExpress t-shirts and caps to send to PDC to give away from our booth. Look at all these boxes of books lurking deep inside our PDC booth.

We are giving away all 1000 books from this first load to PDC attendees from our booth. If you are at PDC swing by and get your own copy, and if you meet up with some of the authors they'll be glad to sign your copy if you want.

Here is Paul Kimmel, one of the authors posing with the 1001st and by far the largest copy of the book. Not all of the books are so large.

If you can't make it to PDC, you can also find the book on Amazon.

BTW: If you happen to have the VCL platform subscription, by a quirk of Delphi IDE history, you also have our ASPx controls.

Delphi at PDC

2009-11-13T15:00:00Z

As you may have heard by now, Devexpress is again a top level sponsor of Microsofts Professional Developers Conference (PDC) again this year. Here's the button, so you know it's fair dinkum.

This is a pretty big deal for us, because it's an opportunity to show off what we have been working on for the past year to one of the largest audiences of .NET developers. But PDC is not just about Microsofts development tools like say a TechEd (which we have also sponsored). Rather PDC is about Professional development for the Microsoft Platform ... in other words it's pretty much a Windows Developer Conference although naturally many attendees are exclusively .NET developers.

So why might Delphi developers be interested in a Microsoft conference?

Well ... with the exception of the handfull who still use Kylix we're pretty much all Windows developers. The future of the Windows Platform is very important to Delphi developers because it's the future of our applications too.

I expect there will be many Delphi developers at PDC this year including those like me who use .NET for web development and corporate applications and Delphi for shrinkwrapped executables. I look forward to meeting up with developers from many component vendors like CodeGear and RemObjects among others that build both .NET and VCL based products, as well as independant Delphi developers.

I'm flying from Australia to be at PDC and this year I have an attendee pass to go to all the keynotes and sessions, although you will also find me around the DevExpress booth during most booth hours. So If you use Delphi hunt me down and we'll talk.

Borlands latest product is pure genius!

2009-10-26T00:08:00Z

No not THAT Borland ... Oh no no no , I mean THIS one.

I give you Borlands Australia - purveyors of Macadamia Shortbread on a Chocolate base. What a stroke of genius to combine the 2nd great gift of the Scots, with the great Aussie "bush tucker" Nut, and dip it in Chocolate. Now if only they produced a low-sugar version for Diabetics .... well I can dream can't I.

Speaking of Dream Products, as you may know I've been a Delphi 7 hold-out for some time. Full disclosure: CodeGear are pro-active at making sure all 3rd parties have a license of the latest products, those go straight to our VCL Dev team which is how we can be so quick to release compatible updates when CodeGear ships a new release. Personally I still use D7 for Native Development, although I did use D2009 recently to do the CodeRage presentations and it really did feel like a better Delphi 7. Lately I've been trialing Delphi 2010 and that to me feels like a better Delphi 2009.

We have probably all heard of the "Even numbered Delphi" myth, and from most reviews it's clear that Delphi went through a tough patch earlier this decade, but it seems to me that all the releases since Borland sold CodeGear to Embarcadero have shown significant incremental quality improvements. I can't say that I need Touch or Gestures but with Win 7's release this week they are certainly timely, Plenty of minor usability features in the IDE like IDE insight are a whole bunch of "nice to have" and I'd personally like to start seeing what I can do with the new RTTI.

Of course Developer Express will continue to make components for whichever versions of Delphi most of our customers use (currently 6,7,2005,2006,2007,2009,2010 for Build 47 ), but I'm personally going to get with the times (although I will miss CodeRush).

BTW: If you think that CodeGear are adding features to Delphi that aren't relevant to you, let them know by spending 30 mins on their Delphi 2010 Survey. Personally I put a vote toward Native cross-compilation for the IPhone, even if that may not specifically be an opportunity for DX, I reckon that would be a must upgrade feature for me personally and I was glad to see it on the Poll rather than having to write it in. Disagree with me? Go vote on the poll for what features you want CodeGear to spend their limited resources on.

More new VCL controls - v47 and a new ExpressLayout Control

2009-10-16T14:25:00Z

We're in the final stages of preparing our latest VCL Component Suites v47 for release, including a brand new major release of ExpressLayout Control v2, minor updates to ExpressSkins library, ExpressQuantumTreeList and ExpressBars, a new beta of the upcoming major update to the ExpressPrinting library v4 (including new PDF features), and of course we've fixed many bugs and implemented minor features suggested by customers..

Active VCL Subscribers as always will get the first look - we are planning to make available a release candidate today (Friday) with a view to publish a release version of the entire subscription next week assuming no show stoppers. Active Subscribers will also be first to get the release edition in their Client Center accounts as soon as it is released. Shortly after we expect to have ExpressLayout Control v2 available for independent purchase.

So what is this ExpressLayout thingy then?

Well it is a container for applying consistent UI rules, enabling run-time customization, and automating the creation of clean crisp resolution independent UIs.

I've spoken before about just how important Run-time customization can be. But the feature that everyone loves is the ability to automatically layout UIs with consistent rules, and have the application just look good no matter how your form is re-sized.

ExpressLayout Control v2 includes a bunch of new features including sizing handles on individual controls. If you re-size an individual control every container it is in and all it's linked controls (like labels) automatically adjust.

The ExpressLayout Control works with many regular Delphi controls, but works best with our own ExpressEditors so we plan to include all the Editors from the ExpressEditors library into the ExpressLayout Control v2. We also have added auxiliary layout items like custom empty spaces, splitters, labels, and separators that you can add to your application using the Customization form.

You can drop an empty space between two other controls.

Select it ...

Re-size it ...

and you will have padding now between your controls that is honored no matter how you re-size your application.

A Separator is a visual UI element that you can place between two elements ...

and it shows up as a vertical or horizontal line.

A Splitter control takes that one step further to allow your end users to re-size layout elements.

Just drop it between two adjacent elements.

... and your form will get a splitter control that your end users can use to re-size layout elements with the layout control making sure that all controls respect your consistent UI rules.

Finally we have a Label Item which is a visual control that works as a separator that you can put some text on to give your UI additional sign-posting.

Just drop it on your form between layout elements, give it some text in the Customization Form.

Put it all together and you have a tweaked UI that follows all the consistency rules with re-sizability, sign-posting, and custom white space.

Finally we have added the ability to optionally collapse layout groups using a + and - button in the top right corner. We've also exposed the ability to add your own custom buttons (such as the Orange Close button in this example) so you can add your own custom actions for groups.

The ExpressLayout Control v2 due for release next week, should hopefully be a very powerful addition to your toolbox.

Grids - Center of the data universe?

2009-10-05T13:43:00Z

Here at Developer Express we have a lot to thank the humble Grid for. As you probably know the QuantumGrid was our first really popular Component Suite, and we have been able to extend that with a broad range of embeddable editors, and ultimately take the grid concept in many different directions from the 90 degree transform of the Vertical Grid, the hierarchical TreeList, to the "Slice-n-Dice" of the Pivot Grid, and even the sparse form of the Spreadsheet. From our start with VCL and ActiveX we've brought many of these to new platforms like Winforms, ASP.NET, WPF and soon Silverlight.

The QuantumGrid these days has almost as many lines of code as the VCL itself, has undergone over a decade of refinement, and offers drop in functionality that is I reckon unequaled by any other Component suite on the market.

In some ways we probably have a grid oriented view on development. Sure we have other popular suites like Reporting and Menu Bars and of course CodeRush, but the grid lies at the core of many of the applications our customers tell us they build. Rather than trying to work out what data a user may want to see, the QuantumGrid allows a developer to offer up all the data and let the customer sort/group/filter using familiar UIs (from Access, Excel and Outlook) into whatever shape they need, and then with one line of code use the PrintingSystem to turn it into a custom report. It's pretty powerful stuff.

I remember the first time I used a Devexpress suite, 3 years before I was to join the company, I was working on tools for analyzing Risk. We had to show a lot of data from thousands of individual financial instruments. We used the QuantumGrid because it gave our customers the ability to sort/group/filter that large amount of data. Sure we could have built a custom grid from scratch, and added new ways to show the data as customers were able to identify their requirements and iterate through many request-implement-deliver cycles ... or we could just embed the QuantumGrid and focus on the math.

So what is your QuantumGrid story? Are Grids that important to your development?

What I learned at CodeRage

2009-09-19T08:34:00Z

Last week's virtual CodeRage developer conference was a good place to hang out if you are a Delphi developer.

I've been doing Delphi conferences since 1995 when I lived in Australia and traveled to BorCon in the US ... which meant I would be on a plane for 14 hours each way, and several timezones away from my paying clients for over a week.

Despite that, BorCon was the highlight of my professional year. I was able to network among peers and potential clients. It was a good chance to see what 3rd party component and tools vendors had done in the past year, and to hear how CodeGear had move the platform forward in the same time. It was also good to be able to meet up with old friends who were also Delphi developers, and feed their addictions to Tim-Tams.

Many of us have since moved to other platforms following evolving demand for the kind of software development we do, although as I mentioned in a previous post Delphi aint dead yet and I noticed a lot of long time Delphi guys at CodeRage in the audience as well as doing presentations.

You can find replays of all the CodeRage sessions at http://conferences.embarcadero.com/coderage/sessions.

Check out Cary Jensens presentation on 9 Thread Synchronization Options in Delphi Compared which was an excellent summary of the array of options available to Delphi developers.

Bob Swart did an interesting presentation on building Smart Clients with Delphi and RemObjects

Ray Konopka always delivers a professional presentation, and Creating Custom VCL Component Designers was no different.

You can find mine here

Tour through DevExpress VCL Suites

The Technology of the QuantumGrid

Apparently the most watched was Delphi and Subversion which I'm just downloading now to watch later. The other day I turned a Windows Home Server into my personal Subversion server for my .NET development using AnkhSVN to integrate Subversion support into Visual studio 2008. I'd like to add integrated Delphi IDE support as well (I'm currently using Tortoise to integrate Subversion into explorer).

So which presentations did you attend or download? Any recommendations?

Technology of the QuantumGrid - Source

2009-09-19T05:56:00Z

In my last blog post, I spoke of how the QuantumGrid was able to implement selectable subcomponents to add a bunch of properties, without contributing to a noisy experience in the Object Inspector.

I presented in my CodeRage session a way to do that for their own components, let me show how that works (sample code attached).

I'm going to build an example using a trivial component as the parent container and two trivial persistent classes as child delegates. Firstly make a Project Group and add two packages, a run-time only one called cxSpecializedComponent and a design-time only one called dclSpecializedComponent. When building components I usually add a test project (TestSpecializedComponent.dpr) with a simple form that uses the control I am building.

You may recognize the naming convention as the one used by Developer Express in our cross platform components. This trick will work for Kylix as well as Delphi. At CodeRage I was using Delphi 2009 (and the screen shots from my last blog post was using Delphi 7) but the same trick will work in Delphi 4+ and CBuilder 4+ all the way up to RAD studio 2010.

The run-time package

In the run-time package we are going to put our parent component TParent, a base class for all children called TCustomChild, and two descendants from it called TChildOne and TChildTwo.

The TParent must have a property for storing an instance of a TCustomChild, an instance of its class type and its class name. We will need a class registration mechanism to register all the child classes to and return the type give a class name.

Let's look at the interface for the run-time package;

type
TCustomChild = class; // Base class for all Child classes
TCustomChildClass = class of TCustomChild; // type of the child Base class

TParent = class(TComponent)
private
    FChild: TCustomChild;
    FChildClass: TCustomChildClass;
    procedure SetChildClassName(const Value: String);
    function GetChildClassName: String;
    procedure SetChildClass(const Value: TCustomChildClass);
public
    property ChildClass : TCustomChildClass
      read FChildClass write SetChildClass;
    procedure CreateChild; virtual;
    procedure DestroyChild; virtual;
published
    property ChildClassName : String
      read GetChildClassName write SetChildClassName;
    property Child : TCustomChild
      read FChild write FChild;
end;

TCustomChild = class(tPersistent)
private
    FBaseText: String;
published
    property BaseText : String
      read FBaseText write FBaseText;
end;

TChildOne = class(TCustomChild)
private
    FOneText: String;
published
    property OneText : String
      read FOneText write FOneText;
end;

TChildTwo = class(TCustomChild)
private
    FTwoText: String;
published
    property TwoText : String
      read FTwoText write FTwoText;
end;

const
sChildOne = 'Child One';
sChildTwo = 'Child Two';

function GetRegisteredChilds : TcxRegisteredClasses;

To do our magic we will expose the TParent.Child property (which contains an instance of the child class), but give it a drop down affect that sets the class type by it's name and creates an instance of the child class. It's all pretty simple to implement, so let's have a look at some code.

First the registration machinery, I am using TcxRegisteredClasses a utility class from a Devex unit called cxClasses, if you don't have the Express Quantum Grid you will have to build one but the exercise is trivial so I won't bore you with the details;

var
FRegisteredChilds: TcxRegisteredClasses;

function GetRegisteredChilds : TcxRegisteredClasses;
begin
if FRegisteredChilds = nil then
FRegisteredChilds := TcxRegisteredClasses.Create;
Result := FRegisteredChilds;
end;

initialization
GetRegisteredChilds.Register(TChildOne, sChildOne);
GetRegisteredChilds.Register(TChildTwo, sChildTwo);
finalization
GetRegisteredChilds.Unregister(TChildOne);
GetRegisteredChilds.Unregister(TChildTwo);
end.

Note we are registering our child classes in the singleton class registration object, and later on we can retrieve the type of any class from its name, that will be used mostly by the design-time editors to complete the magic.

The Children don't need any implementation, so let's finish off the run-time unit by implementing TParent;

procedure TParent.CreateChild;
begin
if FChildClass <> nil then
FChild := FChildClass.Create;
end;

procedure TParent.DestroyChild;
begin
FreeAndNil(FChild);
end;

function TParent.GetChildClassName: String;
begin
if FChild = nil then
Result := ''
else
Result := FChild.ClassName;
end;

procedure TParent.SetChildClass(const Value: TCustomChildClass);
begin
if FChildClass <> Value then
begin
    DestroyChild; // remove the preexisting Child Instance
    FChildClass := Value;
    CreateChild;   // create a new Child Instance
end;
end;

procedure TParent.SetChildClassName(const Value: String);
begin
ChildClass := TCustomChildClass(GetRegisteredChilds.FindByClassName(Value));
end;

The important thing to note in the implementation of the parent is that by setting the ChildClassName property the ChildClass property holding the class type of the Child to be used is created and an instance of the selected class constructed in the Child property (And if one was there previously it was destructed first).

The design-time package

The design-time package will be "installed" in the palette and will include a Register procedure that registers our component, and 2 property editors that will do our magic.

All you need in the interface is a register procedure.

procedure Register;

In the implementation you will need to access CodeGears design-time units, in versions of Delphi from 6 onwards they were not available in source or in run-time packages so you will have to require designide.dcp in your design-time package. Here is the uses clause for the implementation of the Design-time unit.

uses
Types, DesignIntf, DesignEditors, VCLEditors,
DsgnIntf, TypInfo, Classes,
SpecializedComponent, // our run-time component
cxClasses; // for TcxRegisteredClasses generic class registration class

Now we need to make a Class Property editor descendant that tells the TParent component to construct a new child class by giving it a class name chosen from a drop down. The prototype for that class will look like this;

// Property editor to provide a dropdown selection of registered classes and expose nested properties
type
TParentChildProperty = class(TClassProperty)
protected
    function HasSubProperties: Boolean;
public
    function GetAttributes: TPropertyAttributes; override;
    function GetValue: String; override;
    procedure GetValues(Proc: TGetStrProc); override;
    procedure SetValue(const Value: String); override;
end;

Now our property is going to have a Jekyll and Hyde personality change depending on whether we have an instance in the Child property. If we don't have a Child instance then it will be a drop down property editor (a regular Class Editor where you select a class from a given list), if we do it will be a subcomponent editor.

The HasSubProperties method will be used to gate that personality change. If we already have a Child class instance then HasSubProperties will return true, but if we have selected multiple components we need to check them all.

function TParentChildProperty.HasSubProperties: Boolean;
var
I: Integer;
begin // do all components being edited have the ChildClass set
for I := 0 to PropCount - 1 do
begin
Result := TParent(GetComponent( I)).Child <> nil;
if not Result then Exit;
end;
Result := True;
end;

The GetAttributes method actually does the work of setting up the different persionalities. Note: paVolatileSubProperties is available in Delphi6 and up only, but the property editor will function just fine in earlier IDEs (where all sub properties where assumed to be volatile).

function TParentChildProperty.GetAttributes: TPropertyAttributes;
begin
Result := inherited GetAttributes;
if not HasSubProperties then
Exclude(Result, paSubProperties);
Result := Result - [paReadOnly] + [paValueList, paSortList, paRevertable, paVolatileSubProperties];
end;

Now we need to populate the drop down list from our Component registration object.

procedure TParentChildProperty.GetValues(Proc: TGetStrProc);
var
I: Integer;
begin
for I := 0 to GetRegisteredChilds.Count - 1 do
Proc(GetRegisteredChilds.Descriptions[ I ]);
end;

When a value is selected from the drop down it will be a class name. We then have to tell the TParent in the Object inspector to go ahead and make one of those and put it in its Child property. Then we call Modified to tell the object inspector to redraw this editor, and in doing that getAttributes will be called and the new personality established.

procedure TParentChildProperty.SetValue(const Value: String);
var
ChildClass: TCustomChildClass;
I: Integer;
begin
ChildClass := TCustomChildClass(GetRegisteredChilds.FindByClassName(Value));
if ChildClass = nil then
ChildClass := TCustomChildClass(GetRegisteredChilds.FindByDescription(Value));
for I := 0 to PropCount - 1 do
TParent(GetComponent(I)).ChildClass := ChildClass;
Modified;
end;

We flesh out the editor by giving it the text we want to display when it has a valid class.

function TParentChildProperty.GetValue: string;
begin
if HasSubProperties then
Result := GetRegisteredChilds.GetDescriptionByClass(TCustomChild(GetOrdValue).ClassType)
else
Result := '';
end;

Finally, you need to expose the components and property editors to the IDE in the register procedure. Note we are actually removing the property ChildClassName from the Object Inspector by giving it a nil editor. We do this because with the TParentChildProperty editor we are serving a dual purpose of selecting the class type and fixing it's sub-properties in the object inspector.

procedure Register;
begin
RegisterComponents('RAM', [TParent]);
RegisterPropertyEditor(TypeInfo(String), TParent, 'ChildClassName', nil);
RegisterPropertyEditor(TypeInfo(TCustomChild), TParent,'Child', TParentChildProperty);
end;

Can I add child events in the same way?

At Developer Express we have built utility classes to enable events to be cascaded in the same way properties are. This is of course a proprietary technology and can not be redistributed; however for completeness I will show how to use these classes.

If you are building components for developers who already have the Express Quantum Grid 4, for example custom editors that use the Express Editors 4 architecture, you can require the package dclcxLibraryVCLXX where XX is the compiler initial (D,C,K) and the version (ie; D4, C5, K3) and you will be able to descend from our nested event editors.

You will have to use the unit cxPropEditors in the design-time unit.

{$IFDEF DELPHI6}
Types, DesignIntf, DesignEditors,
{$IFDEF VCL}
    VCLEditors,
{$ENDIF}
{$ELSE}
DsgnIntf,
{$ENDIF}
TypInfo,
Classes,
SpecializedComponent,
cxPropEditors,   // for NestedEvent property editor classes
cxClasses;       // for TcxRegisteredClasses generic class registration class

In your TParent you will have to add a dummy editor to use as a placeholder for the location that the events of the child will be hosted.

property ChildEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;

The design-time editor is quite simple with the Developer Express , simply descend from the TcxNestedEventProperty editor and override the GetInstance method to return a reference to the Child component being edited.

// Property Editor to expose nested events from persistent sub components
type
TParentSpecilizationEventsProperty = class(TcxNestedEventProperty)
protected
function GetInstance: TPersistent; override;
end;

function TParentSpecilizationEventsProperty.GetInstance: TPersistent;
begin
Result := TParent(GetComponent(0)).Child;
end;

And finally register it for the dummy event made earlier.

RegisterPropertyEditor(TypeInfo(TNotifyEvent),
                         TParent,
                         'ChildEvents',
                         TParentSpecilizationEventsProperty);

Next time you rebuild your design-time package, you will see any events in the Child component classes exposed in the TParent object inspector.

Can I freely use this technique?

You are welcome to use this technique in your components as long as you do not redistribute any Developer Express units.

To build one set of source for all platforms I suggest building a file similar to the cxGridVer.inc file from ExpressQuantumGrid 4 which will map versions into conditional definitions that will allow you to build uses statements that work correctly for all platforms. You only need this for the Design-time unit.

unit RegSpecializedComponent;

{$I cxGridVer.inc}

interface

procedure Register;

implementation

uses

{$IFDEF DELPHI6}

Types, DesignIntf, DesignEditors,

{$IFDEF VCL}

VCLEditors,

{$ENDIF}

{$ELSE}

DsgnIntf,

{$ENDIF}

TypInfo,

Classes,

SpecializedComponent,

cxClasses; // for TcxRegisteredClasses generic class registration class

Conclusion

This gives components a very powerful in-place delegation mechanism that will allow you to partition your components into container classes and behavior classes that the containers delegate to, so palette components can have multiple behaviors allowing you to reduce the palette clutter without reducing functionality.

I've attached some source code, including code to implement events if you have the Quantm Grid.

Technology of the QuantumGrid - Object Inspector tricks

2009-09-07T14:28:00Z

I'm presenting a couple of sessions at CodeRage this week. The first is, called "The technology of the Quantum Grid" which will go live at 1pm PDT, Tuesday Sept 8th.

This session is about how the QuantumGrid (since v4) does some Object Inspector magic to enable developers to specialize components by allowing you to dynamically add sub-components - it's a very nice way of extending a class in many diverse directions while keeping the property noise to a minimum.

You can see this happening when you add a column to a grid and select its Properties property. To see this drop an empty grid on a form, click on ‘Customization’ and add a column to the GridDBTableView and click on it and you will see the Column object in the Object Inspector.

Notice that the Properties Property is a regular drop down editor, this is the site that an editor class for all cells in this column will be defined. If you click the drop down button you will see the list of available editor classes that can be used, these can be editors from the Express Editors package, or even your own descendants that you have registered with the Grid architecture.

Now if you actually select a class, let’s say the CalcEdit class, something special happens to the Properties property. It changes into a subcomponent property of the class that was selected in the Dropdown.

In this example we now have the class name CalcEdit in the Properties property and since this is now a subcomponent property we also have all the properties (and events if you look at the events page) specific to just that class. In effect we have a container class called TcxGridDBColumn that we can specialize with any of a number of utility classes simply my selecting the type from a drop down.

If you were to drop down and select a different element, say a CurrencyEdit you would then see all the properties and events specific to that class.

This is a very powerful way to build component specialization by delegation to contained classes, and represents a new way of using the Delphi Object Inspector to improve in place customization of classes, and reduce the clutter of components in the Delphi Palette. Now you don’t have to have different column classes for each type of Editor, you have just one generic column class that can embed and delegate to custom editors.

Want to add the same kind of functionality to your own components?

Come to my CodeRage session at 1pm PDT, on Tuesday the 8th of September (sign up here ) ... and I'll show you how.

CodeRage - might be the future of Developer Conferences

2009-09-05T13:27:00Z

CodeGear's CodeRage event next week is a virtual Developer Conference - Really!.

Speakers record their presentations in advance using TechSmiths excellent Camtasia (which is the same technology we use to record for tv.Devexpress.com ), the presentations are produced on a schedule from CodeGears web site and Speakers and attendees are able to mingle after the presentation for a Q&A session using Live Meeting. I have two presentations, one a tour through the suites of the DevExpress VCL Subscription and the other a look into some of the technology of the QuantumGrid.

Even if you don't use Delphi, the conference is a chance to see what the state of the art is in Prism (The 1st class .NET language based on Delphi) and hear a different perspective on the same issues that face all developers - and the price (Free) can't be beat.

The only downside for me is that Speakers have to have their presentation "in the can" way ahead of time, rather than just stepping on stage with an rough agenda of what you plan to show and cutting into some code and seeing where the presentation and audience feedback take you. I usually prefer those more dynamic presentations (both as attendee and speaker) than ones "on rails" ... but the upside for me is I don't have to take 2 x 14 hour plane trips in coach, and a week and a half of downtime for a 4 day conference ... not to mention the swine flu. So it's all good

I may have mentioned I lived in Las Vegas for 4 years while CTO of Developer Express (2002 - 2006), and there are many good things to love about Vegas for a small business ... especially a Technology related one. Cheap direct airfares to everywhere, cheap accomodation, low taxes and every couple of months many of your customers come to town for a conference - and no one does a conference quite like Vegas does whether it be a massive event like CES or a smaller more intimate event like DevConnections.

It seems however that the era of the large mega conference with 10,000+ software developers all converging upon one spot on the globe for a week, might be coming to an end - no doubt killed off by the financial times we live in. Which is going to be tough for destinations like Las Vegas that had become so good at hosting them - I think there will still be some big events like PDC and WWDC, but I suspect more narrowly focused technology conferences will be very tempted to go virtual.

For those of you who do decide to hang out in my presentations ... see ya next week.

And for the rest ... see you virtually at a Developer Conference real soon.

DevExpress VCL subscription ready for Delphi 2010 and Windows 7

2009-09-05T02:59:00Z

Go get your bits ... the DevExpress VCL Subscription v46 is live and ready, willing and able to be installed on a fresh new Delphi 2010.

The complete "What's new" is over here.

But for those who like to skip straight to the chase ... the highlights are;

RAD Studio 2010 support
Windows 7 Skin (+3 more)
PDF output for the Printing System beta bits in the build
**NEW** Layout Control beta bits in the build
... and a handful of other small but usefull feature requests fulfilled

I've been playing with the PDF stuff so far (managed to get a demo of the Printing System outputting PDF into my CodeRage presentation for next week) and it's looking pretty solid.

I know a bunch of guys are keenly awaiting the next Layout Control too. If you want to install either of the 2 betas, you have to install 46 fully first to get the shipping versions, and then go back and re-run the install in Modify mode to replace the shipping bits with the beta bits

NB: The new Layout demos assume the shipping Printing System and vice versa so those demos might not build happily if you install both betas at the same time ... I did, but then I'm just the kind of risk taker that installs two beta components and I did it on Delphi 2010 on Windows 7 running in a VM on a Mac ... Mwahahahaha.

As always let support@devexpress.com know if you notice anything strange with the beta bits.

Delphi! Who goes there?

2009-08-25T00:18:00Z

I recently posted about the imminent non-death of Delphi ... and lots of people contacted me to let me know that they too noticed that Delphi wasn't going anywhere any time soon.

Several people pointed out how hard it is to find Delphi developers, or Delphi jobs ... of course these are most likely related ... certainly both are true although I reckon it wouldn't take long to teach a good C# developer how to become a handy Delphi developer if your project really needs one more Delphi developer, and just about all the C# developers here at Devexpress were once Delphi developers so going the other direction is quite easy too. I guess what I am saying is that I wouldn't let a lack of exclusively Delphi developers, stop you from using Delphi if it's the best solution.

Quite a few people were quite happy to give opinions why Delphi "lost" to C#, missing the point of my post which was that Delphi and C# are both excellent solutions for answering different questions.

While I am on the topic of that blog post, a few people pointed out some errors in my post. eg: while I spoke of AutomatedQA's Test Complete I Showed AQTime ... oops sorry about that. AFAIK both are built using Delphi and have high resolution timing made easier by virtue of being built using Delphi. I also referred to Quests Toad product being built using Delphi, and as an example showed a screenie of Toad for SQL Server ... unfortunately it turns out that while some versions of TOAD were built in Delphi, TOAD for SQL Server was built in .NET. Mea Culpa!

Speaking of blogs about Delphi, I have few more Delphi tech blog posts planned before I have to get back to blogging about XAF and ASPx and other DX technologies I am working with.

I've also been working with Emil and Amanda to produce scripts for Devexpress.TV screencasts of using our VCL products ... over the past week we've been building a few on using the SpellChecker component and you can find those here. If these prove popular we hope to produce more VCL screencasts ... so feel free to let other Delphi developers know about these, and let's see if we can get the view counts above some of the .NET screencasts.

I'm also planning to present a couple of sessions at Embarcaderos's CodeRage conference in early September

PARTNER SOLUTION: The Technology of the QuantumGrid, 1:45pm Sept 8th
A look at how the DevExpress QuantumGrid is able to present radically different views, and how you can do the same thing in your own components to expose different UI behaviors at design-time through the property inspector, and in your applications at runtime.

and

PARTNER SOLUTION: DevExpress, 1pm Sept 9th
A tour through the broad offering of components from Developer Express.

You can register for this conference here ...

Once this goes live I'll blog more about the code involved in enabling your own components to cascade different views like the Quantum Grid.

While I'm on the topic of blogging and Delphi ... who else is blogging about their Delphi development? It's always interesting and often surprising to learn more about what developers are doing with Devexpress components, and I reckon our VCL team will also get a kick out of how the VCL components that they work on every day are being used in the real world ... so what are you guys using our VCL components for?

Delphi ain't dead yet

2009-07-31T08:00:00Z

I've heard people talking about the imminent death of Delphi for 15 years, and the language is only 14.5 years old. It seems that every year or so some wise guy lobs a bomb into the blogosphere like Rest In Peace Delphi.

But the reality is that commercial developers are using Delphi every day to build applications that we all probably use every day, and most users probably don't even know were written in Delphi.

It is true that over the past 8 years C# has been embraced by a lot of corporate development shops (some ex-Delphi, probably many more ex-Java), because in an homogenous environment where you can control that every deployment will be to Vista with .NET 3.5 pre-installed and a common path to a local SQL server, a C# (or VB.NET) application is the path of least resistance. But there are environments where a native Delphi application maintains a distinct advantage.

Shrink Wrapped applications

One strength of Delphi is that you compile into a windows executable, and your app just runs on almost every version of Windows built in the past decade. No need for a specific version of an application deployment framework (like .NET) to be available.

Nick Bradbury, who you may know as the developer of commercial hits like HomeSite and TopStyle uses Delphi and gives probably the best rationale on his blog for a micro-ISV developing applications choosing Delphi.

You may have also noticed the recent testimonial from EC Software the developers of Help&Manual who use ExpressBars to build a new revolutionary UI in their Delphi application.

Delphi is a good choice for creating shrink wrapped applications, or shareware applications for Windows, or just generally any application for deployment to a heterogeneous windows environment.

Real-time applications

Delphi allows the same kind of "to the metal" control of hardware as any Microsoft C++ application that would be impossible in a platform abstracted away from the hardware like Java or C#.

You may know Developer Express is a geographically diverse company, with developers and evangelists spread around the globe (even the outback of Australia). We use email, and IMs to communicate and coordinate but when text is just not rich enough we use Skype which was built in Delphi.

Test Complete from AutomatedQA was built entirely in Delphi and is able to produce millisecond resolution automated testing for any kind of application development.

If you are building applications like these that have to be responsible for the number of CPU cycles they consume, Delphi may be a good choice.

Component based development

Sure you could build real time apps like Skype, or Shrink Wrapped apps like HomeSite in MicroSoft C++ but if your competitor is using Delphi they will leave you in the dust because they can leverage a broad palette of drop in components from third party companies like Developer Express that will propel an application development closer to completion.

Imagine if you were trying to compete with Quests all purpose Database tool TOAD using something other than Delphi and didn't have the luxury of being able to drop in a component like the Express QuantumGrid with all it's sorting/grouping/filtering and master/detail functionality at your fingertips.

It would take a team of developers several years just to build that functionality (http://www.devexpress.com/Products/VCL/ExQuantumGrid/) - and yet any Delphi developer can buy a component for $399 and drop it into his application and be there already.

Delphi Community

Finally there is an entire ecosystem of commercial developers making a good living from supporting Delphi, from CodeGear who are always working to extend the language, to companies like Developer Express building broad offerings of components, and even companies like Quest and Automated QA building developer tools using Delphi. Here at DevExpress we have a commited team of developers that just love working with, and extending Delphi ... it's not as big a market as .NET is for us, but many of us were also Delphi developers before .NET and still use Delphi regularly.

Sure there are some scenarios where .NET has significant advantages over Delphi (Prism, which is both, is a subject for another blog post) - heck there are many scenarios where Ruby on Rails is a better platform than Delphi - but there are definite problems for which Delphi is a good solution.

Like Mark Twain, it seems that the rumors of the death of Delphi have been greatly exaggerated.

Runtime customization, at a fraction of the cost!

2009-07-15T14:38:00Z

I may have mentioned that I worked in the USA for for 7 years before returning to Australia, the last 4 of those for Developer Express in Las Vegas. Prior to that I was working on Wall Street building financial analytics applications in Delphi for exposing credit risk in complex financial products. However the job that I first moved to the USA to do, was for a Company in Florida who built an HRMS/Payroll application built in Delph. The job I was brought in to do was to implement Run-time customization.

Run-time customization is the ability for your customers to tweak the app you deliver them to show customized information. In the case of a Payroll application, lets say one of your customers has some parking spots they assign to employees in their package - you might not want to clutter up your apps employee benefit screens with a field for storing an allocated parking spot for the 99.9% of your customers who don't package parking. So Run-time customization lets your customer (or a 3rd party consultant) add that field to just their own application. It's a pretty useful feature to deliver in ERP applications, but it's tricky to implement and requires some complex and fiddly RTTI (Run Time Type Information) development.

Back then I knew quite a bit about RTTI, in fact I used to have a regular gig speaking on the topic at Borland conferences, which is how I got this job - but you know there is a much easier way to implement Run-time customization that is not only a lot cheaper than importing an Australian RTTI expert for 12 months, it's also a lot quicker.

You've probably heard of the ExpressLayout Control which is a library for helping you deliver a consistent User Interface. UI consistency, as you probably recognize is the critical element that differentiates great applications that users love from the merely functional. What is not so well known is that this library also enables Run-time Customization.

Check out this *video ...

... so with just one line of code you can implement run-time customization that allows your customers to tweak the User Interface of the apps you deliver to them and all you have to do is add a few generic fields (CustomField1, CustomField2, etc) to your table and drop a few hidden controls on the form and let the ExpressLayout Control do the rest of the work.

At $149 for the Layout control with full source, I can tell you its a fraction of the cost of importing an Australian RTTI expert to join your development team.

Let us know how you use the ExpressLayout Control ... I'd love to blog about applications that use this or any of our components (VCL or otherwise).

* BTW: we're working on producing more videos on our VCL products, and some more on this topic ... watch this space.

PDFs, VCL applications and more Revolutionary UIs.

2009-07-10T10:54:00Z

No rest for the wicked ... no sooner have the VCL development team here at Developer Express shipped Build 45, than they are back in the labs working on the next release. This time I was able to sneak a peek at the TODO list in front of the team working on the ExpressPrinting System™ v4 which should be available as a beta in Build 46 (Providing, as always, it has met our Quality standard).

The Printing System is a remarkable product that lets you take a grid that your user has specialized by sorting, grouping, re-ordering and filtering the data to get it looking just the way they want and then with one line of code print the data out, in that shape, as a report. It works with a whole range of controls from our Quantum, Vertical, and Pivot Grids, as well as Rich Edits, Schedulers, regular Forms, SpreadSheets and many more. It really is the fastest way to deliver printed reports in a Delphi application.

Did you notice the recent case study from EC Software the developers of Help & Manual, and the revolutionary UI they created using the Ribbon control from ExpressBars™? Well the Printing System team have become inspired and are adding the Ribbon control to the Print Preview dialog. So with v4 if you have the ExpressBars product installed you will be able to see the Ribbon in the Preview Dialog, and if you have the ExpressSkins™ library installed you can skin all the dialogs with any custom skin.

But that's just the appetiser, can you guess the biggest new feature from the following sneak peek?

That's right! With ExpressPrinting System v4 you will not only be able to print complex controls with ease, you can generate PDF files from the result.

Personally I can't wait to be able to drop a PivotGrid, a Reportlink and a Generate PDF button on a form, hit compile, and ship the exe to a particular middle level manager I know who is always trying to contract me into building him new reports on the same data.

Apple logos pop up in the strangest places

2009-06-25T16:00:00Z

So I'm sure you probably noticed more than a few DXers talking about Apples lately, Our CTO Julian just tweeted that his new IPhone 3GS was on it's way to him, and Evangelist Gary just blogged about new features in the latest IPhone 3.0 software, the other day Silverlight guru Azret had as his FaceBook status "Hating myself for loving the IPhone UI", and you probably recognize these likely lads and that ... let's face it ... "In Your Face" logo on the back of the latptop they are both clearly mocking.

That logo is so "In Your Face", that at a recent conference (run by a company that shall not be named) where Oliver was speaking, a conference room functionary was dispatched by some marketing weasel to slap a sticker over the Apple logo on his laptop while he was in mid-present.

I've just got myself a new 17" MacBookPro myself (I'll blog later about how to set up a Mac for developing .NET apps) and I've also been using an IPhone for 6 months so I guess I'm as much an Apple Fanbois as anyone else here ... but that gaudy Apple logo is giving me the irits. I paid enough for this laptop, I'm not going to give away any more free advertising to them.

What I really want is to get some inkjet printed surface tension held "sticker" to put over it ... maybe I'd do an old school Apple II Rainbow (My first PC back in 1980) or a map of Australia or such.

...

Speaking of Australia, as you may know we're drifting as a continent towards Japan at a rate of about 6cm a year ... or about one ninth of a cubit for my nonmetricated friends. As we are headed north we seem to be dropping bits of giant limestone islands off the southern edge of the continent, and in our trip around Australia we took a very windswept trip out to see some of these called the 12 Apostles.

This is the southern most edge of Australia, and that wind is bitterly cold comes directly from Antarctica and smells of penguins. You can see some of the 12 Apostles in the background. Those are the giant limestone Islands, and because they are essentially chalk left out in the elements they erode rapidly and dramatically.

Check out the interesting way this one is eroding ... at its top left ... see that hole in the limestone that you can see through to the waves behind?

That bloody Apple logo ... it's everywhere.