# Tips of Delphi #

Delphi HTML Preview

2009-02-28T08:33:00.001-08:00

HI,

Acabei de preparar um exemplo com uma rotina que achei para visualizar um código HTML no componente WebBrowser sem precisar criar um arquivo.

Antes quando precisa exibir algo em HTML no programa, eu criava um arquivo .html com o código e caregava no componente. Mas recentemente precisei exibir um código HTML armazenado no banco de dados. Poderia ter feito no esquema que já sabia, mas decidi fazer algo mais decente, hehehe. Pegar o código e carregar diretamente no componente TWebBrowser.

Download do exemplo AQUI.

Até Mais.

SmartInspect 3.0 Session Improvements

2008-08-18T14:21:00.002-07:00

This is the first part of a series showing some of the major new features and improvements of the upcoming SmartInspect 3.0 release. Yep, that’s right; SmartInspect 3.0 is coming very soon now! As with the previous major release, it will contain quite a few new features that are directly based on customer feedback. We are really grateful for all the feature requests, bug reports and ideas for improvements that we received over the years. Without them, SmartInspect wouldn’t be near as good or complete as it is today.

The first improvement I would like to write about is actually not a new feature. It’s more like a set of several enhancements to the existing SmartInspect session concept. Back then in 2003 and 2004 when we first planned which features SmartInspect 1.0 should shave, we quickly agreed that we should provide users with a way to group and categorize related log messages. We have chosen the session concept because it’s a) easy to understand and b) maps very well to existing related concepts such as user sessions in web applications.

In retrospect we are happy that we went with sessions for two reasons. First, sessions turned out to be one the key features of SmartInspect. Although sessions are a somewhat advanced feature that new users often ignore (which they easily can, because they don’t have to care about it when they are learning SmartInspect). But once they are getting used to it and are using SmartInspect in more complex applications, they quickly see the advantages of sessions over other logging concepts.

The second point is a bit more technical. Since the entire library design relies on sessions, it would have been difficult to integrate sessions at a later point without breaking existing customer code. And because you should be very careful to not break existing customer code with a new version of a dev tool, we are glad that we got the basic library design mostly right in the first attempt.

Although we got most of the design right, there were a few missing features. The first new feature in SmartInspect 3.0 regarding sessions is the new log level support. This is probably the most often requested session related feature that we incorporated into the new version. Log level support for sessions means that you are now able to configure log levels on a per-session basis. This allows you, for example, to only log errors and warnings in your application, except for your database module where you want SmartInspect to generate a very detailed log (e.g., for debugging or auditing purposes).

Another improvement in SmartInspect 3.0 is the new ability to configure sessions via SmartInspect configuration files. This allows you to enable, disable or configure specific sessions without recompiling your application. This can come in very handy if you have to dynamically enable or disable logging for certain application modules on production systems or at customer sites.

The last new session enhancement is the support for so-called session defaults. Session defaults let you specify default values for session attributes like the Active status or the background color of log entries in the Console. This is very useful in situations where you are working with many sessions and need a way to change the base settings of all instances.

We will introduce other new features and improvements of SmartInspect 3.0 in the next few days here on our blog.

Keyword

Delphi

Anonymous Methods - When Should They Be Used?

2008-08-18T14:21:00.001-07:00

Anonymous methods are generating a lot of buzz in the Delphi community right now, being one of the bigger changes heading our way in the forthcoming Tiburon (Delphi 2009), along with Unicode and Generics.

Unlike Unicode and Generics however, the usefulness of anonymous methods is not nearly as clear.

On Joel On Software

Joel On Software has been invoked as an authority. Unfortunately, as Joel himself has previously admitted, he does not actually use Delphi, and a great deal of the usefulness he sees in anonymous methods seems to stem from this fact, in that what he describes as the principal benefits of anonymous methods has always been achievable in Delphi.

To paraphrase his material on this point:

    procedure Cook(const aIngredient1, aIngredient2: String;
                   const aCookingMethod: TCookingMethod);
    begin
      Alert('get the ' + aIngredient);
      aCookingMethod(aIngredient1);
      aCookingMethod(aIngredient2);
    end;

Cook( 'lobster', 'water',   PutInPot );
Cook( 'chicken', 'coconut', BoomBoom );

Joel asks: Can your language do this?

If the language is Delphi, yes. We don’t need anonymous methods for this.

But that is not the only use for anonymous methods espoused by Joel. He goes on to talk briefly about threading, before seeming to me to go off at something of a tangent to talk about MapReduce, where the applicability of anonymous methods is a little hard to fathom (in the context of languages that “can do this”) and I’m certain that the actual Google MapReduce implementation is a great deal more complex than Joel’s summary, but I’m not so sure that anonymous methods were critical to it’s success, rather than just happening to be a part of it.

One wonders if they would have featured at all if Google had used Delphi.

Anonymous Methods and Threading

In a different blog, Lars Fosdal also mentions threading.

Coming at the subject with the Delphi perspective that Joel does not have, Lars aligns the benefits of anonymous methods against the failings of TThread. Not unreasonable, given that TThread is the “out of the box” approach to threading in Delphi and it undeniably has a number of shortcomings. But TThread is not the only game in town for Delphi developers. I myself have needed a more lightweight approach to threading in the past. So I made one. I called it TMotile (a work by Peter F Hamilton brought the term motile to my attention, and the fit was obvious in my mind).

My TMotile class can be used in two ways. First to execute some procedure in a fire-and-forget background thread:

    procedure SomeProcedure;
    begin
      // ...
    end;

TMotile.Execute( SomeProcedure );

Or secondly in a way perhaps more familiar to those already used to TThread:

    TMyMotile = class( TMotile )
    protected
      procedure Execute; override;
    end;

    procedure TMyMotile.Execute;
    begin
      // ...
    end;

TMyMotile.Create;

With anonymous methods that fire-and-forget usage could be made simpler:

TMotile.Execute( procedure
                 begin
                   // ...
                 end; );

Of course, that “simpler” observation is, I think, debatable. If it is “simpler” at all, then actually it isn’t by very much, and arguably it introduces an unacceptable level of noise into the code. This doesn’t appear to be the case when viewed in isolation, but in the context of a longer sequence of code where only one statement is invoked to create a thread to handle background execution of some other code, seeing the body of that background code is “noise”.

There is an even greater advantage when the body of the anonymous procedure captures state from the context in which it is created. In those situations then this usage simply cannot work without anonymous methods, requiring a subclass of TMotile (or TThread) in order to explicitly capture that state from the context and make it available to the threaded procedure:

    TMyMotile = class(TMotile)
    private
      fContextVar: ...;
    protected
      procedure Execute;
    public
      property ContextVar: .. write fContextVar;
    end;

    procedure TMyMotile.Execute;
    begin
      ..  fContextVar  ..;
    end;

mm := TMyMotile.Create;
mm.ContextVar1 := SomeContextValue;
mm.Execute;

Which can be replaced with:

mm := TMotile.Execute( procedure;
                       begin
                         .. SomeContextValue ..;
                       end; );

Which is undeniably neat. Both in the sense that is it clever and a great deal more concise. But I am still not convinced that this convenience is worth getting all that excited about - It has not enabled anything that was previously impossible, nor even especially difficult either to implement or to understand, and that noise is still there.

Indeed, anonymous methods do not even eradicate the infrastructure that is required to support it, they just hide it.

If it’s hidden, I can’t fix it or improve it or adapt it to better suit a specific use. If it’s hidden I may never the less need to take it into account to understand what unfamiliar code does and how - hiding it just makes it that much harder to identify and requires me to bring that knowledge of the hidden details with me.

For one thing of course, if this threaded code should later evolve and require some mechanism to pass information back to the context that originated it - or some other context - having that threaded code represented by an identified and referencable object provides exactly the mechanism we need. Without any such visible device, yet more wizardry is needed to provide that mechanism without resorting to simply exposing and extending the pretty basic infrastructure.

With Great Anonymity Comes Great Responsibility

Having anonymous methods in the language does not compel us to use them, and unlike Generics or even Unicode to an extent, using them in your code will not compel others to use them either, if they do not wish to. So what’s the harm?

Well, of course, the same could be said of with - and indeed, the similarity is quite striking. Both provide a means of hiding an implementation detail and avoiding the onerous task of encumbering that detail with an identity. with is, somewhat famously, regarded with disdain for the way that this hiding of details introduces problems. Not least when debugging (and the prospect of debugging anonymous methods is similarly intriguing, to say the least).

So if we all only use anonymous methods responsibly, we’ll be fine.

Which call to mind Eddie Izzard’s response to the NRA’s assertion that “Guns don’t kill people, people kill people” …..

…and monkeys do too (if they have a gun)

Speaking of Eddie Izzard, if you haven’t heard his Death Star Canteen sketch, then allow YouTube to introduce you to in glorious LegoVision.

Any excuse.

Other Parallels

No not a further examination of threading, but the use of one thing to draw a parallel, or a comparison, with something else. In this case, let us imagine we are putting together a web site, and on some of our pages we have some content that isn’t directly relevant to the page it is on. Content that certainly doesn’t have to be read at the time, but which perhaps isn’t likely ever to be read alone. It’s not going to appear in our site navigation or even the table of contents necessarily.

It’s content, but it doesn’t have an absolute identity outside of some other context in which it is referenced. On the printed page, it would be a footnote or an entry in the bibliography.

These things to a written language are, essentially, what anonymous methods are to our code.

So why do we have footnotes? Why do we use links in web pages, instead of just quoting, verbatim and inline, the content we would like the reader to perhaps come back to later, and just require them to skip over it in the meantime.

The question is of course rhetorical.

This is essentially what anonymous methods will bring to your source code.

I may never write code this way myself, but I am not looking forward to the first time I have to read someone else’s code written that way.

So, When Should They Be Used?

The title of this post posed a question, and it’s only fair that I answer it.

As things stand, I would have to say that anonymous methods should be used only when you absolutely have to, and so far I have not yet seen an example where anonymous methods are the only way to achieve anything.

I may yet change my mind, and more examples have been promised by CodeGear. But CodeGear didn’t invent these things, and they aren’t new, as plenty of people point out - compelling and obvious examples should already be readily available, albeit not in Delphi.

Where are they?

Keyword

Delphi

Resizing a Non-Resizable Form

2008-08-17T06:56:00.001-07:00

One control that I have not seen in the line-up of new controls in the VCL for Tiburón is a size grip.

Most people may not even realise that this control exists, even though it is part of Windows itself and is really quite useful. Fortunately, implementing it ourselves is truly trivial.

What is a Size Grip?

A size grip is the small triangular control, usually in the lower right hand corner of a window that provides an indication that the window is resizable and is also a grab-point that the user can use to resize the window itself.

You will see one if you place a status-bar control on a resizable form:

Example of a Size Grip

If the form is not resizable, the grip does not appear in the status bar.

But what if I have a form that I want to be sizable, but which does not have a status bar, doesn’t need a status bar, and which perhaps in all other respects doesn’t even look resizable?

Imagine, for example, that I have redesigned a dialog box so that it now needs to be resizable….

If you look at the dialog box shown in that link, you will see that it is resizable but offers no immediately obvious visual cue that this is in fact the case. It clearly doesn’t need a status bar.

What would be useful in such cases is a way to add a size grip without having to use a status bar.

And this is exactly what a size grip control does for us.

The Implementation

As I mentioned, the implementation of such a control is trivial. So trivial that the entire implementation is provided below. No need for a download in this case.

interface

  uses
    Classes,
    Controls;

  type
    TSizeGrip = class(TWinControl)
    protected
      procedure CreateParams(var Params: TCreateParams); override;
      procedure CreateWnd; override;
    public
      constructor Create(aOwner: TComponent); override;
    end;

implementation

  uses
    Windows;

{ TSizeGrip }

  constructor TSizeGrip.Create(aOwner: TComponent);
  begin
    inherited;

    ControlStyle := [csOpaque, csFixedWidth, csFixedHeight];

    Anchors := [akRight, akBottom];
    Cursor  := crSizeNWSE;
    Height  := 11;
    Width   := 11;
  end;

  procedure TSizeGrip.CreateParams(var Params: TCreateParams);
  begin
    inherited;
    CreateSubClass(Params, 'SCROLLBAR');
    Params.Style := Params.Style or WS_CLIPSIBLINGS or SBS_SIZEGRIP;
  end;

  procedure TSizeGrip.CreateWnd;
  begin
    inherited;
    Left := Parent.ClientWidth - Width - 1;
    Top  := Parent.ClientHeight - Height - 1;
    SendToBack;
  end;

As you can see, a size grip is in fact a special form of the built in SCROLLBAR Windows control class.

This code should work in any Win32 version of Delphi. In my case since I use Delphi 7 I use dotted unit names and have it implemented in Deltics.Controls.SizeGrip. In earlier Delphi versions you will need to use a unit name with no dots.

And yes, we should probably use system metrics to size the control.

The implementation has the control place itself in the lower right hand corner of it’s parent, and stay there. But how do we ensure that we only show the control if the form is resizable?

Well, actually, we don’t need to worry about that. Simply placing the control on a form makes the form resizable (via the size grip) even if that form would normally not be resizable. That is, if the user moves their mouse over the size grip it will change to the resizing cursor and they can resize the form by grabbing the control and dragging.

So the user can see that the dialog is resizable and is provided with the means to resize the form, even if the form has no border at all, such as this one, with border style bsNone:

Resizable, Borderless Form

Getting this is as easy as adding:

    with TSizeGrip.Create(self) do
      Parent := self;

To a form constructor or OnCreate event.

In fact, in my applications I can simply write in any form constructor or OnCreate event:

    HasSizeGrip := TRUE;

Any form.

How is that possible? HasSizeGrip is not a property of TForm, so where does it come from?

I’m saving that for next time.

Keyword

Delphi

MapQuest and Delphi

2008-08-16T16:54:00.001-07:00

A few weeks ago I started down the path of discovering how to GeoCode addresses for Delphi. This is related to a project we had where we wanted to show a map of a given point and then show facilities located near it on a map. I had originally started working with maps.live.com (which is a MS site). They have a decent little interface for JS that seemed to work for what I wanted AND I didn't have to store the annoying little GeoCoding addresses anywhere. This works great if all you want is a single address. For instance, the code below works for single addresses:


<html>
   <head>
      <title>Address Lookup </title>
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      <script type="text/javascript" src="http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6"></script>
      <script type="text/javascript">

      var map = null;
      var findPlaceResults = null;
      function GetMap()
      {
         map = new VEMap('myMap:newmap');
         map.LoadMap();
         map.Find(null,'100 Enterprise Way, Scotts Valley, CA 95066', null, null, null, null, true, true, null, true, GetCoordinates);
      }

     function GetCoordinates(layer, resultsArray, places, hasMore, veErrorMessage)
     {
        findPlaceResults = places[0].LatLong;
        var myShape = new VEShape(VEShapeType.Pushpin, findPlaceResults);
        myShape.SetTitle('CodeGear');
        myShape.SetDescription('100 Enterprise Way<br>Scotts Valley, CA 95066<br>'+findPlaceResults.toString());
        map.AddShape(myShape);
     }

     </script>
   </head>
   <body onload="GetMap();">
      <div id='myMap:newmap' style="position:relative; width:800px; height:600px;"></div>
   </body>
</html>

The problem showed up when I went to add the facilities to the map. Thinking it would all work the same way, I added the same Map.Find code for each facility in the state of interest and voila. Except the voila was, "How come I only get one pushpin?" not "See how great this works!" It turns out that part of the answer is the MS VEMap object works asynchronously. I could live with that if the map moved around a little as it added pushpins... well, at the very least, I could just hide the map until it was done.

Unfortunately, MS also made the calls non-reentrant. This is actually what they document the problem as. To me, the code IS non-reentrant in that it never calls itself. Apparently, our definitions of re-entrant differ significantly. To MS, non-reentrant means that you have to wait for the asynchronous call to complete before you can call it again. Of course, Javascript has little support for "waiting". I was able to create a work around using a do {} while (!completed); but it causes the browser to complain mightly, ties up a lot of CPU and is just generally ugly.

Seeing that this wasn't going to work very well, I went back to the drawing board. If I actually could provide the Lat/Lng for each object, the problem would go away. It turns out that there are not very many services that want to let you do this for free using a desktop tool. If you are willing to do a web mashup you can get away with quite a bit, but the traditional languages are left out in the cold for the most part.

This is where MapQuest comes in. They have a free service (you have to register, but that's it) that will let you have access to their mapping systems. Of course, they have no interface for Delphi, but they did publish their XML specifications so it's not too hard to write one. Keep in mind that you have to comply with the MapQuest TOS. The major one for me was that you can't use the Lat/Lng addresses with any other system than theirs. That means I can't use maps.live.com to produce my maps, I have to figure out how to use MapQuest. Considering my other choices was a complete web mashup rewrite or some commercial system that was going to cost a fortune, I think I'll live within those parameters.

I've only implemented the single interface I needed so far (GeoCoding), but the other interfaces are equally easy. This code is virtually identical (in the HTTP POST) as my DHL code. I've reposted the whole thing here for those needing a complete unit but will likely factor it out for my personal use.

Enjoy!

1. This is how the classes are used. I assume you recognize that the txtXXX are just text box fields and the resolver form has a single control on it that is a list box (other than the Select / Cancel buttons).


uses mapquest_api, w_AddyResolver;

procedure TForm1.btnGeoCodeClick(Sender: tobject);
var geocode:TMapQuestGeoCoder;
    index, ix:integer;
begin
geocode:=TMapQuestGeoCoder.Create;                                               //create the geocoder object
geocode.Password:='YOUR PASS';                                                   //assign the password and client id you got from mapquest
geocode.ClientID:='YOUR ID';                                                     //this will NOT work without it!!!

geocode.Address    := edtAddress.Text;                                           //assign the address info you want to code
geocode.City       := edtCity.Text;
geocode.State      := edtState.Text;
geocode.PostalCode := edtPostalCode.Text;
geocode.Country    := edtCountry.Text;

if geocode.getFromMapQuest(true) then                                            //this will send the info to mapquest and return the results
   if geocode.ReturnedAddresses.Count>0 then                                     //if we got a response
      begin
      if geoCode.ReturnedAddresses.Count=1 then                                  //if there's only 1, no need to show a resolver
         index:=0
      else                                                                       //we got multiple responses, the user will have to resolve which addy is correct
         begin
         index:=-1;                                                              //default to failure
         for ix := 0 to geoCode.ReturnedAddresses.Count-1 do                     //for each addy
            with geoCode.ReturnedAddresses.Address[ix] do
               addyResolver.lb.Items.Add(Address+' '+City+' '+State+' '+Country); //load the listbox
         if addyResolver.ShowModal=mrOk then                                     //prompt the user, if they select one, mrOk will be set
            index:=addyResolver.lb.ItemIndex;                                    //get the addy
         if index<0 then exit;                                                   //if the user failed to pick, get out
         end;

      lblLat.Caption:=geoCode.ReturnedAddresses.Address[index].Lat;              //display the lat and long values
      lblLong.Caption:=geoCode.ReturnedAddresses.Address[index].Long;
      end;

end;

2. And this is the actual unit that does the work. BTW, the XML parser I'm using is OpenXML, a freely available, full source implementation that works for Delphi and Kylix.


unit mapquest_api;

interface

uses classes, contnrs;

type
   //base class, you must derive descendants to make use of this class
   //in order to successfully communicate with mapquest, you must attach YOUR ClientID, Password and APIKey
   //you can register for free at mapquest.com
   TMapQuestAPI = class
      private
         fClientID : string;
         fPassword : string;
         fAPIKey   : string;
         fURL      : string;
      protected
         function getXML:string; virtual; abstract;
         procedure parseResponse(response:TStringList); virtual; abstract;
      public
         constructor Create;
         function getFromMapQuest(enableLogging:boolean):boolean;

         property ClientID : string read fClientID write fClientID;
         property Password : string read fPassword write fPassword;
         property APIKey   : string read fAPIKey   write fAPIKey;
         property URL      : string read fURL;
      end;

   TReturnedAddyList=class;

   //this descendant will implement the GeoCoder functionality from mapquest
   //you must comply with mapquests terms of service, check mapquest.com to make sure
   //that works for you
   TMapQuestGeoCoder = class(TMapQuestAPI)
      private
         fAddress   : string;
         fState     : string;
         fCity      : string;
         fCountry   : string;
         fPostalCode: string;
         fCounty    : string;
         fReturnedAddresses : TReturnedAddyList;
      protected
         function getXML:string; override;
         procedure parseResponse(response:TStringList); override;
         procedure ClearReturnedAddys;
      public
         constructor Create;
         destructor Done;

         property Address:string    read fAddress    write fAddress;
         property City:string       read fCity       write fCity;
         property State:string      read fState      write fState;
         property Country:string    read fCountry    write fCountry;
         property PostalCode:string read fPostalCode write fPostalCode;
         property County:string     read fCounty     write fCounty;
         property ReturnedAddresses:TReturnedAddyList read fReturnedAddresses;
      end;

   //container class for a returned address
   TReturnedAddy = class
      public
         Address,
         City,
         State,
         PostalCode,
         Country,
         County,
         Lat,
         Long      : string;

         constructor Create(aAddress, aCity, aState, aPostalCode, aCountry, aCounty, aLat, aLong:string);
      end;

   //you can get back MULTIPLE addresses if you send in something that is generic enough
   //in that case, the COUNT will be > 1. Make sure you implement a resolver screen to handle this
   TReturnedAddyList = class(TList)
      protected
         property Items;
         property List;
      public
         function getAddy(index:integer):TReturnedAddy;
         property Address[Index:Integer]:TReturnedAddy read getAddy;
      end;


implementation

uses sysutils, dialogs, IdHttp, IdSSLOpenSSL, IdResourceStringsCore, IdLogFile, xdom_3_2;

const
   CR = #13;
   LF = #10;
   EOL = CR+LF;
   xmlEOL = EOL;

type
  // this is a descendant of TidLogFile, it will create a plain text file with
  // information about the transfer session
  TlogFile = class(TidLogFile)
  protected
    procedure LogReceivedData(const AText, AData: string); override;
    procedure LogSentData(const AText, AData: string); override;
    procedure LogStatus(const AText: string); override;
  public
    procedure LogwriteString(const AText: string); override;
    class function buildLogLine(data, prefix: string) : string;
  end;

// this ensures the output of error and debug logs are in the same format, regardless of source
class function TlogFile.buildLogLine(data, prefix: string) : string;
begin

  data := StringReplace(data, EOL, RSLogEOL, [rfReplaceAll]);
  data := StringReplace(data, CR,  RSLogCR,  [rfReplaceAll]);
  data := StringReplace(data, LF,  RSLogLF,  [rfReplaceAll]);

  result := FormatDateTime('yy/mm/dd hh:nn:ss', now) + ' ';
  if (prefix <> '') then
    result := result + prefix + ' ';
  result := result + data + EOL;
end;

// ---------------------------------------------------------------------------

procedure TlogFile.LogReceivedData(const AText, AData: string);
begin
  // ignore AText as it contains the date/time
  LogwriteString(buildLogLine(Adata, '<<'));
end;

// ---------------------------------------------------------------------------

procedure TlogFile.LogSentData(const AText, AData: string);
begin
  // ignore AText as it contains the date/time
  LogwriteString(buildLogLine(Adata, '>>'));
end;

// ---------------------------------------------------------------------------

procedure TlogFile.LogStatus(const AText: string);
begin
  LogwriteString(buildLogLine(AText, '**'));
end;

// ---------------------------------------------------------------------------

procedure TlogFile.LogwriteString(const AText: string);
begin
  // protected --> public
  inherited;
end;

// ---------------------------------------------------------------------------

{ TMapQuestAPI }

//create the class, default everything to blank
constructor TMapQuestAPI.Create;
begin
fURL:='';
fClientID:='';
fPassword:='';
fAPIKey:='';
end;

// ---------------------------------------------------------------------------

//send the http post to mapquest and return a stringlist with the results (or nil if error)
function TMapQuestAPI.getFromMapQuest(enableLogging:boolean): boolean;
const logFileName = 'http.log';
var
  plainData : TStringList;
  HTTP     : TidHTTP;
  response : TStringList;
  logFile  : TLogFile;

  //as mentioned in my article on http post for DHL, indy converts CR/LF pairs to &.
  //This causes a problem when sending xml data.
  //This routine will remove CR/LF pairs and replace them with a space
  procedure ConvertCRLFtoSpace;
  begin
    if plainData.Count > 1 then begin
      // break trailing CR&LF
      plainData.Text := StringReplace(Trim(plainData.Text), sLineBreak, ' ',[rfReplaceAll]);
    end else begin
      plainData.Text := Trim(plainData.Text);
    end;
  end;

begin
  result:=false;                                                           //by default, we get failure response in error
  plainData := TStringList.Create;                                         //init the container for xmiting the xml
  try
     plainData.Text:=getXML;                                               //get the xml from the class and put it in the container
     Http:=TidHTTP.Create(nil);                                            //create the http class
     try
        HTTP.readTimeout := 10000;                                         //setup the http timeouts and xmit types
        HTTP.ConnectTimeout := 10000;
        HTTP.Request.Contenttype := 'text/xml';
        HTTP.HTTPOptions := [];
        if enableLogging then                                              //if we are going to log the events (useful if there's a problem)
           begin
           logFile := TLogFile.Create(nil);                                //create the log file
           logFile.FileName:=logFileName;                                  //set the default log file name - NOTE: you could get fancy with this, but I normally don't use it
           logFile.Active:=true;                                           //activate the log file (creates the file and intializes everything)
           HTTP.Intercept := logFile;                                      //set the logFile to the intercept of the HTTP to capture the events
           end;
        response:=TStringList.Create;                                      //create the response container
        try
           ConvertCRLFtoSpace;                                             //make sure you strip cr/lf pairs out or the xml will be malformed
           response.Text := HTTP.Post(URL, plainData);                     //post the xml and receive the response xml
           result:=true;
           parseResponse(response);
        finally
           response.Free;
        end;
     finally
        Http.free;                                                         //free the http class
     end;
  finally
     plainData.Free;                                                       //free the container class
  end;

end;

{ TMapQuestGeoCoder }

procedure TMapQuestGeoCoder.ClearReturnedAddys;
var ix:integer;
begin
for ix := 0 to fReturnedAddresses.Count-1 do
   fReturnedAddresses.Address[ix].Free;
fReturnedAddresses.Clear;
end;

constructor TMapQuestGeoCoder.Create;
begin
fURL:='http://geocode.free.mapquest.com/mq/mqserver.dll?e=5&';            //this is the free server address. if you sign up for a different type of account, you'll want to set this to your account type
fReturnedAddresses:=TReturnedAddyList.Create;
end;

destructor TMapQuestGeoCoder.Done;
begin
ClearReturnedAddys;
fReturnedAddresses.Free;
end;

function TMapQuestGeoCoder.getXML: string;                                //returns the xml formated per the MapQuest API
const geocodeXML =
   '<?xml version="1.0" encoding="ISO-8859-1"?>'+
   '<Geocode version="1">'+

      '<Address>'+
        '<AdminArea1>%s</AdminArea1>'+
        '<AdminArea3>%s</AdminArea3>'+
        '<AdminArea5>%s</AdminArea5>'+
        '<PostalCode>%s</PostalCode>'+
        '<Street>%s</Street>'+
      '</Address>'+

      '<GeocodeOptionsCollection Count="0"/>'+

      '<Authentication Version="2">'+
        '<Password>%s</Password>'+
        '<ClientId>%s</ClientId>'+
      '</Authentication>'+
   '</Geocode>';

begin
result := Format(geocodeXML, [Country,State,City,PostalCode,Address,Password,ClientID]);  //make the request xml for geocding an address
end;

procedure TMapQuestGeoCoder.parseResponse(response: TStringList);
var
    DOC:TXMLtoDomParser;
    DOM:TDOMImplementation;
    XML:TDOMDocument;
    LocCollection:TDomNodeList;
    Geo,
    Node:TDomNode;

    //you can't trust that the xml contains ALL element names so this wraps the testing conditions up
    //to safely get the node values or a blank when not in the xml
    function SafeGetNodeValue(node:TDomNode; name:string):string;
    var DomElement:TDomElement;
    begin
       result:='';
       DomElement:=Node.GetFirstChildElement(name);
       if DomElement=nil then exit;
       if DomElement.ChildNodes=nil then exit;
       if DomElement.ChildNodes.Length=0 then exit;
       result:=DomElement.ChildNodes.Item(0).NodeValue;
    end;

    //same as the previous but designed to get a subelement (LatLng/Lat or LatLng/Lng)
    function SafeGetSubNodeValue(node:TDomNode; rootName, subName:string):string;
    var RootElement,
        SubElement:TDomElement;
    begin
       result:='';
       RootElement:=Node.GetFirstChildElement(rootName);
       if RootElement=nil then exit;
       SubElement:=RootElement.GetFirstChildElement(subName);
       if subElement=nil then exit;
       if subElement.ChildNodes=nil then exit;
       if subElement.ChildNodes.Length=0 then exit;
       result:=subElement.ChildNodes.Item(0).NodeValue;
    end;

begin
   ClearReturnedAddys;                                                                             //make sure there are no saved addys
   DOC:=TXMLtoDomParser.Create(nil);                                                               //create the xml parser
   DOM:=TDOMImplementation.Create(nil);                                                            //create the dom
   try
     DOC.DOMImpl:=DOM;                                                                             //assign the dom to the xml parser
     XML := DOC.StringtoDom(response.Text,'mapquest.xml',nil,true);                                //convert the response text to and xml document. NOTE: 'mapquest.xml' forces the correct creation of the node structures. If you pass blank, you get NO NODES
     try
        LocCollection := XML.GetElementsByTagName('LocationCollection');                           //get the location collection (group of geoaddresses 1..n)
        if LocCollection=nil then exit;

        Node:=LocCollection.Item(0);                                                               //get the top level node
        Geo:=Node.GetFirstChildElement('GeoAddress');                                              //get the first GeoAddress
        while Geo<>nil do                                                                          //while we have a GeoAddress
           begin
           fReturnedAddresses.Add(TReturnedAddy.Create(SafeGetNodeValue(Geo, 'Street'),            //addy
                                                       SafeGetNodeValue(Geo, 'AdminArea5'),        //city
                                                       SafeGetNodeValue(Geo, 'AdminArea3'),        //state
                                                       SafeGetNodeValue(Geo, 'PostalCode'),        //zip
                                                       SafeGetNodeValue(Geo, 'AdminArea1'),        //country
                                                       SafeGetNodeValue(Geo, 'AdminArea4'),        //county
                                                       SafeGetSubNodeValue(Geo, 'LatLng', 'Lat'),  //Latitude
                                                       SafeGetSubNodeValue(Geo, 'LatLng', 'Lng')   //Longitude
                                                       ));
           Geo:=Geo.NextSibling;                                                                   //get the next GeoAddress
           end;
     finally
        XML.Free;                                                                                  //free the XML document
     end;
   finally
      DOM.Free;                                                                                    //free the dom
      DOC.Free;                                                                                    //free the xml parser
   end;
end;

{ TReturnedAddy }

//create the object and initialize the data
constructor TReturnedAddy.Create(aAddress, aCity, aState, aPostalCode, aCountry, aCounty, aLat, aLong: string);
begin
Address:=aAddress;
City:=aCity;
State:=aState;
PostalCode:=aPostalCode;
Country:=aCountry;
County:=aCounty;
Lat:=aLat;
Long:=aLong;
end;

{ TReturnedAddyList }

//easy way to get access to the accumulated returned addresses
function TReturnedAddyList.getAddy(index: integer): TReturnedAddy;
begin
result:=TReturnedAddy(Items[index]);
end;

end.

Writing reusable code - part 2

2008-08-15T13:18:00.003-07:00

There are a few practices that will help you write solid, maintainable, reusable code. A lot of software practitioners of greater fame than mine have written about these before, but it doesn't hurt to repeat good advice.

Note that I in no way claim this to be the one and only true way to software development nirvana, but just some practices that work for me. Your own opinions and experiences on the topic will be greatly appreciated, so feel free to comment.

Keep It Simple, Stupid
Reusable code should be kept low-feature. It can be a challenge to avoid feature creep and dependency bloat, so make an effort to follow the KISS rule. The more sophisticated stuff you add, the more you will need to "fix" and not to forget: Test! - when inheriting from the class.

Design for extendability
When you design a reusable class, you really have to define the scope of what you want to achieve. Decide on the basic feature set, then evaluate the possible offspring to this class and conceivable additional features, but to adhere to the KISS rule - you should not add the features until you need them. Instead, spend a little time on evaluating the impact of the features and put in any necessary hooks and leave enough comments to allow you to rediscover why you put them in in the first place.

Later, if you absolutely have to add a feature and cannot add it in an inherited class - make sure you don't break existing behavior in class instancing. A common mistake is to change a default property value in the base class constructor, which some derived class assumed had a specific state or value.

...and on the point of assumptions...

Never Assume, Always Assert
I bet you never heard that one before! :) Use Asserts to check your assumptions. It will save you from a number of embarrassing moments of broken code. The purists probably want this done in unit testing, but it can help add clarity to your code if it is done in the actual library code. Think of it as design by contract.

procedure TSimpleClass.ActOn(aParameter:TSomeClass; aValue:Integer);
begin
  // Ensure aParameter is assigned and of correct type 
  Assert(Assigned(aParameter) and (aParameter is TSomeClass));
  // and that aValue is in legal range
  Assert(aValue >= 0);
  ...

Using asserts like these will help you catch runtime problems faster. They also will remind you of what conditioning you need to do before you call the method, and what assumptions you can make within the routine itself.

Avoid Dependencies
When you start pulling in code from other libraries or classes, you should consider the level of dependency that you introduce. A simple extra nice-to-have attribute may come with a payload of extra code that hardly ever will be called. If possible, put the extra attribute in a separate descendant class in a separate unit. The less code you have to compile in, the better.

Embrace Polymorphism
When you create classes that are intended as foundation for descendant classes, you should consider how to best support polymorphic instancing.

For example - if you are writing a container class that will hold a polymorph collection of elements - you may want to have a virtual class function that return the default class type used to instance new elements in the container, instead of just instancing the base element class. Doing so will allow descendant classes make reliable assumptions about the safety of typecasting within the extended methods in the descendant container class.

unit BasicClass;

interface

type
  TElementClass = class of TBaseElement;

  TBaseElement = class(TObject)
  end;

  TBaseContainer = class(TObject)
    class function ElementClass:TElementClass; virtual;
    function ValidElement(anElement:TBaseElement):Boolean;
  end;

implementation

{ TBaseContainer }

class function TBaseContainer.ElementClass: TElementClass;
begin
  Result := TBaseElement;
end;

function TBaseContainer.ValidElement(anElement: TBaseElement): Boolean;
begin
  Result := anElement is ElementClass;
end;

end.

"But..." - you will say; "you can just override methods in the descendant class for the same effect?". Yes, you can and it works well when you add new functionality, but what about functionality that already has been implemented in class higher in your inheritance tree?

unit AdvancedClass;

interface
uses
  BasicClass;

type
  TAdvancedElement = class (TBaseElement)
  end;

  TAdvancedContainer = class(TBaseContainer)
    class function ElementClass:TElementClass; override;
  end;

implementation

{ TAdvancedContainer }

class function TAdvancedContainer.ElementClass: TElementClass;
begin
  Result := TAdvancedElement;
end;

end.

The base class won't have an understanding of it's descendants, so if you want it to be able to work with content from descendant classes, you would either have to override/redo the functionality or - do as above - allow the base class to work with their own child classes as well.

program ExtendableClasses;
{$APPTYPE CONSOLE}
uses
  SysUtils,
  BasicClass in 'BasicClass.pas',
  AdvancedClass in 'AdvancedClass.pas';

procedure Main;
var
  Element1, Element2     : TBaseElement;
  Container1, Container2 : TBaseContainer;
begin
  Container1 := TBaseContainer.Create;
  Container2 := TAdvancedContainer.Create;

  Element1 := Container1.ElementClass.Create;
  Element2 := Container2.ElementClass.Create;

  Writeln('E1: ', Element1.ClassName);
  Writeln('E2: ', Element2.ClassName);

  Writeln('E1 valid in C1: ', Container1.ValidElement(Element1));
  Writeln('E2 valid in C1: ', Container1.ValidElement(Element2));

  Writeln('E1 valid in C2: ', Container2.ValidElement(Element1));
  Writeln('E2 valid in C2: ', Container2.ValidElement(Element2));
end;

begin
  try
    try
      Main;
    except
      on E:Exception do
        Writeln(E.Classname, ': ', E.Message);
    end;
  finally
    Write('Press Enter: ');
    Readln;
  end;
end.

This particularly goes for dialogs and forms that use a polymorph class - make a virtual class function to enable overriding the class instancing. Avoid the rigidly defined TSomeInheritableClass.Create constructs and call the virtual class type function instead.

Note on constructors
When I finally "got" OOP as opposed to structured programming, it was hard to drop the structured way of thinking when it came to instancing. Most of my classes would only have a constructor that took a ton of parameters to save a few lines at the point of instancing that class.

While this might work well for monomorphic classes, it really will not be good for a class hierarchy, and it took me some time to get to the habit of having a parameterless Create. Today, I almost wish for a compiler hint if I should happen to write constructors that require parameters.

Hide detail with Layers
Think in APIs and layers and try to propagate only content between the layers, and not details that are specific to connectivity, storage, etc. A good layered design will allow you to rip out and replace parts of the architecture without massive rewrites.

When you design your APIs or layers, you should consider leaving space or hooks for piggybacking in more content in yet-to-be defined formats where appropriate.

Isolate Data from the GUI
The less your GUI know about your data, the better. Vise versa, the less your data knows about the GUI, the better. Use a mediating class that does the job of knowing both and how to tie them together. This will ease the job of making the data structures as well as the GUI reusable.

It can be particularly useful to tie your business logic to your data and avoid implementing biz.logic in the GUI presentation. Your data will be easier to move to a different presentation form when the rules are not hard-coded in some draw routine. You don't want to have duplication of biz.logic code between the display routines, the report routines, the export routines, etc.

-

Thats it for now. More on the topic of Layers and GUI abstraction to follow.
Also, part 3 of the reusable grid.

Reusable Grid View - part 3

2008-08-15T13:18:00.001-07:00

Let's take a closer look at how to hijack a pristine TStringGrid and make it our playground without inheriting the grid directly. The VCL class is well designed for reuse and expose properties and event handlers that we easily can grab hold of. The OnDrawCell event is of particular interest to us. That's a good spot to redefine how the grid retrieve and render it's content.

You will be assimilated
This is pretty self explanatory, but what we basically do is hook the draw routine and set up the appropriate number of rows and columns, and their respective default widths.

procedure TGridViewController.Refresh;
var
  ix : Integer;
begin
  if not Assigned(Grid)
   then Exit;

  if not IsEmpty
  then begin // Set Visitor's drawing handler, row and column count
    Grid.Enabled := True;
    Grid.OnDrawCell := DrawCell;
    Grid.RowCount := RowCount + FixedRows;
    Grid.ColCount := Count;
    for ix := 0 to Count - 1  // Set column widths
     do begin
       Grid.ColWidths[ix] := (Objects[ix] as TGridViewColumn).Width;
     end;
  end
  else begin // disable drawing handler, set rows/cols to 1 and fill in 1 "blank"
    Grid.Enabled := False;
    Grid.OnDrawCell := nil;
    Grid.RowCount := 1;
    Grid.ColCount := 1;
    Grid.ColWidths[0] := 0;
    Grid.Cells[0,0] := defaultEmptyCell;
  end;
  if Grid.RowCount > 1
  then begin // Reset header and Row positions in case empty grid overrode them.
    Grid.FixedRows := FixedRows;
    Grid.Row := FixedRows;
  end;
  Grid.Invalidate; // ensure that the grid is refreshed
end;

OnDrawCell
So this is where all the action is... err... actually, not much happens here. Instead we delegate the actual rendering to the column instance.

procedure TGridViewController.DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
begin
  (Objects[aCol] as TGridViewColumn).DrawCell(Grid.Canvas, aRow, Rect, State);
end;

The column instance then again divide the draw into two sections. The outer DrawCell does basic housekeeping of canvas color settings and a little color trickery (a feature that snuck in while I was having fun - my bad).

procedure TGridViewColumn.DrawCell(Canvas: TCanvas; aRow: Integer; Rect: TRect;
  State: TGridDrawState);
var
  FG, ofg,
  BG, obg : TColor;
begin
  with Canvas
  do begin
    ofg:=Font.Color;
    obg:=Brush.Color;

    if (State = []) // Not focused/selected/etc
    then begin
      FG := ofg;
      BG := obg;

      if aRow > 0 // Not a title line
      then begin
        ForeColor(aRow, FG);
        BackColor(aRow, BG);
      end;

      if ofg <> FG then Font.Color:=FG;
      if obg <> BG then Brush.Color:=BG;
    end;

    DrawCellInner(Canvas, aRow - Controller.FixedRows, Rect, State); // The business happens here

    if (State = [])
    then begin
      if ofg <> FG then Font.Color:=ofg;
      if obg <> BG then Brush.Color:=obg;
    end;
  end;
end;

The actual content rendering happens in DrawCellInner. Note that we do an adjustment related to grid layout here. If you look at the line where DrawCellInner is called, we subtract FixedRows from aRow, ensuring that our data is zero offset based.

procedure TGridViewColumn.DrawCellInner(Canvas: TCanvas; aRow: Integer;
  Rect: TRect; State: TGridDrawState);
var
  CellText : String;
  w      : Integer; // String width
  txtAdj : Integer; // old adjust mode
begin
  if aRow < 0
  then CellText := Title
  else CellText := FormattedText(aRow);
  with Canvas
  do begin
    case FAlign of
      taCenter       : begin
                         w:=TextWidth(CellText);
                         if (w>(Rect.Right-Rect.Left))
                         then w := 2
                         else w := Round(((Rect.Right - Rect.Left) - w) / 2);
                         TextRect(Rect, Rect.Left + w,Rect.Top + 1, CellText);
                       end;
      taRightJustify : begin
                         txtAdj:=SetTextAlign(Handle, ta_Top or ta_Right);
                         TextRect(Rect, Rect.Right - 3,Rect.Top + 1, CellText);
                         SetTextAlign(Handle, txtAdj);
                       end;
               else // taLeftJustify
                       TextRect(Rect, Rect.Left+2,Rect.Top+1, CellText);
    end;
  end;
end;

In the inner draw routine we first figure out if we are drawing the title row or a data row. If it is a data row, we call the TGridViewColumn.FormattedText method.

function TGridViewTextColumn.FormattedText(aRow: Integer): String;
begin
  Result := GetTextMethod(aRow);
end;

Does GetTextMethod look familiar? It is the procedure variable which holds the method we implement in our descendant viewcontroller class and pass on when we set up the column. That is the method which actually retrieve the data from the underlying data structure as described in part 2 (GetNumber, GetNumberSquared).

The rest of DrawCellInner measures the retrieved text and ensure it is adjusted as desired and rendered within the cell region.

Magic Colors
Back to ForeColor and BackColor in the outer draw. This is the closest we come to bells and whistles. To make the grid look more sophisticated, I added support for overriding the colors as well as a very simple default rowshading algorithm.

procedure TGridViewColumn.ForeColor(aRow: Integer; var Color: TColor);
begin
  if Assigned(FGetForeColorMethod)
   then GetForeColorMethod(aRow, Color)
  else if DefaultForeColor <> clNone
   then Color := DefaultForeColor;
end;

procedure TGridViewColumn.BackColor(aRow: Integer; var Color: TColor);
begin
  if Assigned(FGetBackColorMethod)
   then GetBackColorMethod(aRow, Color)
  else if DefaultBackColor <> clNone
   then Color := DefaultBackColor;

  if Assigned(FGetShadeColorMethod)
  then GetShadeColorMethod(aRow, Color);
end;

Both these methods start in the same way. The default color have been retrieved from the grid itself in the outer draw. First we check if a color method have been plugged in, if not - we check if a column color override has been set.

For the background color routine, there is another feature - a pluggable shading method. The default row shader looks like this...

procedure TGridViewController.DefaultRowShader(const aRow:Integer; var Color:TColor);
begin
  if ShadeRows and (not Odd(aRow))
  then begin
    Color := Graphics.ColorToRGB(Color); // Translate theme/system colors to RGB
    if  ((Color and $FFFFFF) > $888888)  // Lazy man's luminosity adjustment
     then Color := Color - $080808
     else Color := Color + $080808;
  end;
end;

Too much flexibility? Well, maybe I broke the KISS rule, but no rule without exceptions :) Now I can have static or procedural color adjustments per row as well as per column.

Next: Reusable Grid goes code complete and come with examples.

Stay tuned.

Reusable Grid View - part 2

2008-08-15T06:31:00.004-07:00

The Controller

Our basic TGridViewController will hold a list of TGridViewColumns. I could make a simple array, or I could use TStringList. TStringList is probably one of the best and one of the worst classes in Delphi. So easy to use and so easy to abuse. In this case, I will only need to manage a handful of columns, instead of thousands of lines of text - so it will be ok.

On the abuse side: before you start filling TStringList - consider adjusting the capacity. Resizing the list is EXPENSIVE. Also - fill first, sort later.

Ok, lets take a look at the initial skeleton of the controller class:


  TGridViewController = class (TStringList)
  private
    FGrid : TStringGrid;
    function GetIsEmpty:Boolean;
    function GetCurrentSelectionIndex: Integer;
  protected
    procedure DefineAttributes; virtual; abstract;
    function GetRowCount: Integer; virtual; abstract;
    procedure SetGrid(const Value: TStringGrid); virtual;
    procedure DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
    function MakeColumn(ColType : TGridViewColumnType; aTitle:String; aWidth:Integer; anAlign:TAlignment):TGridViewColumn;
  public
    constructor Create; virtual;
    destructor Destroy; override;
    procedure Refresh;
    function CreateTextColumn(aTitle:String; aGetText:TGetTextMethod; aWidth:Integer = 64; anAlign:TAlignment = taLeftJustify):TGridViewTextColumn;
    property CurrentSelectionIndex:Integer read GetCurrentSelectionIndex;
    property Grid: TStringGrid read FGrid write SetGrid;
    property IsEmpty: Boolean read GetIsEmpty;
    property RowCount:Integer read GetRowCount;
  end;

I won't go into the details on the TGridViewColumn yet, but note the two abstract methods in the controller: DefineAttributes and GetRowCount. To make a working grid, these are what we need to override.

The Grid property identifies the grid that we will control and DrawCell is the method we plug into the grid onDrawCell event. MakeColumn is called by the CreateTextColumn with the appropriate TGridColumnView descendant - hiding the interaction with our parent string list. I guess you already have figured out that IsEmpty simply check the number of rows.

A simple Example

Lets consider the simplest possible example: a grid showing rows with the numbers 1 to 5, and their values squared. Note that the unit is pretty ignorant about what a grid is.


unit DemoNumbersClass;

interface

uses
  Classes, SysUtils, FDCGridViewController;

type
  TViewNumbers = class(TGridViewController)
  private
    function GetNumber(const Row: Integer): String;
    function GetNumberSquared(const Row: Integer): String;
  protected
    procedure DefineAttributes; override;
    function GetRowCount: Integer; override;
  end;

We define two columns, and refer each column to a data retrival method.


implementation

{ TViewNumbers }

procedure TViewNumbers.DefineAttributes;
begin
  CreateTextColumn('Number', GetNumber);
  CreateTextColumn('Squared', GetNumberSquared, 64, taRightJustify);
end;

function TViewNumbers.GetNumber(const Row: Integer): String;
begin
  Result := IntToStr(Row);
end;

function TViewNumbers.GetNumberSquared(const Row: Integer): String;
begin
  Result := IntToStr(SQR(Row));
end;

function TViewNumbers.GetRowCount: Integer;
begin
  Result := 5;
end;

end.

Then we create a Form, drop a string grid on it, tweak some row size settings etc., and add the controller.


unit DemoFDCGridViewController;

interface

uses
  Windows, Messages, SysUtils, Classes, Controls, Forms,
  StdCtrls, Grids, FDCGridViewController, DemoNumbersClass;

type
  TGridViewForm = class(TForm)
    StringGrid1: TStringGrid;
    procedure FormCreate(Sender: TObject);
  private
    Numbers : TViewNumbers;
  public
    { Public declarations }
  end;

var
  GridViewForm: TGridViewForm;

implementation

{$R *.dfm}

{ TGridViewForm }

procedure TGridViewForm.FormCreate(Sender: TObject);
begin
  // Create our controller
  Numbers := TViewNumbers.Create;
  // and introduce the controller to the host grid
  Numbers.Grid := StringGrid1;
end;

end.

And the result:

As you can see, there are a few tweaks that I haven't described yet. Also, I still haven't revealed the simple steps done to invade our host grid.

Stay tuned :)

Writing Readable Code - Formatting and Comments

2008-08-15T06:31:00.003-07:00

I guess there are at least as many coding styles as there are programmers times programming languages. Many of us are conformists, and some of us have our highly personal style, but most of us probably fail at being 100% consistant. Code formatting can probably be considered a slightly religious area, so please feel free to disagree with me :)

So - why bother to put any effort into the formatting anyways? It is not like the compiler care? I mean, apart from the obvious requirement that things should be reasonable readable and not just a jumble of code?

Layout matters. It is significantly easier to pick up code that is consistant in style than wading through spaghetti (or gnocchi) code where the indentation has not been considered much.

I have noticed that my personal style with regards to block formatting definitively is non-conformist. Whenever there is a do, if/then/else, with or without related begin/end, I will probably annoy the heck out of the conformists.

My formatting goals:
• I want clear indication of flow
• I want to separate conditions from actions
• I want room to comment

In the examples below, I will place comments in the individualist examples to give an indication of why I choose to wrap/indent in this way rather than the "global standard"

Let's start with the do in with and the for-loop (I do at times, albeit rarely, confess to the occasional use of with).


// Conformist
  for i := 1 to 5 do Something;

  for i := 1 to 5 do begin
    Something;
    SomethingMore;
  end;
  
  with SomeObject do begin
    Something;
    SomethingMore;
  end;
  
// Individualist
  for i := 1 to 5     // For selected range
   do Something(i);   // get stuff done

  for i := 0 to (count - 1) // For every item
  do begin              
    Something(i);       // Step 1
    SomethingMore(i);   // Step 2
  end;
  
  with SomeObject  // Focusing on this specific item,  
  do begin         // I can add this comment for clarity
    Something;
    SomethingMore;
  end;

The if/then/else statement have too many combinations to even get close to cover them all, so I am only going to do a handful.


// Conformist
  if (SomeVariable = Condition) and (SomeOtherExpression) then
    PerformSomeRoutine;
    
  if (SomeVariable = Condition) and (SomeOtherExpression) then begin
    Code;
    MoreCode;
    LotsOfCode;
  end else OtherCode;

  if Condition then DoFirstAlternative else DoSecondAlternative;
  
  if FirstCondition then DoFirstAlternative 
  else if SecondCondition then DoSecondAlternative
  else DoThirdAlternative;
    
// Individualist
  if (SomeVariable = Condition)    // I always put the condition alone
   then PerformSomeRoutine;

  if   (SomeVariable = Condition)  // Condition X found
   and (SomeOtherExpression)       // Requirement Y fulfulled
  then begin  // we can do our stuff
    Code;
    MoreCode;
    LotsOfCode;
  end
   else OtherCode; // or we ended up with the alternative

  if Condition 
   then DoFirstAlternative   // The Condition compelled us to do this
   else DoSecondAlternative; // Optionally, we explain the alternative 
  
  // Here I find myself doing many different approaches, 
  // depending on the complexity of the logic, and the number
  // of alternatives, but with multiple nested if's, I tend to indent
  if FirstCondition            
   then DoFirstAlternative     // We are doing 1 because ...
   else if SecondCondition 
    then DoSecondAlternative   // We are doing 2 because ...
    else DoThirdAlternative;   // Otherwise, We are doing 3

  // I might chose this approach if it is a long chain
  if FirstCondition            
   then DoFirstAlternative   // We are doing 1 because ...
  else if SecondCondition 
   then DoSecondAlternative  // We are doing 2 because ...
  else DoThirdAlternative;   // Otherwise, We are doing 3

C++/C# and Java people likes to rant about how ugly and verbose our begin / end's are, and I am sure I could rile myself up over their curly brace enclosures and some of the religion connected to those too - but I am not going to go there. However, there are a few things about our enclosures that may be worth thinking over.

Some like to dangle their end's at various indentation levels. I prefer to align it with the matching start of the block (do begin, then begin). Why? It makes it is easier to identify the code path in relation to the condition.

More enclosures doesn't always mean better readability. Here is an example from Indy9(IdTunnelCommon.pas). Kudzu, I love you - but I disagree with your code style in this file :)
(I know I am going to get flamed for this...^^)

procedure TReceiver.SetData(const Value: string);
var
  CRC16: Word;
begin
  Locker.Enter;
  try
    try
      fsData := Value;
      fiMsgLen := Length(fsData);
      if fiMsgLen > 0 then begin
        Move(fsData[1], (pBuffer + fiPrenosLen)^, fiMsgLen);
        fiPrenosLen := fiPrenosLen + fiMsgLen;
        if (fiPrenosLen >= HeaderLen) then begin
          // copy the header
          Move(pBuffer^, Header, HeaderLen);
          TypeDetected := True;
          // do we have enough data for the entire message
          if Header.MsgLen <= fiPrenosLen then begin
            MsgLen := Header.MsgLen - HeaderLen;
            Move((pBuffer+HeaderLen)^, Msg^, MsgLen);
            // Calculate the crc code
            CRC16 := CRC16Calculator.HashValue(Msg^);
            if CRC16 <> Header.CRC16 then begin
              fCRCFailed := True;
            end
            else begin
              fCRCFailed := False;
            end;
            fbNewMessage := True;
          end
          else begin
            fbNewMessage := False;
          end;
        end
        else begin
          TypeDetected := False;
        end;
      end
      else begin
        fbNewMessage := False;
        TypeDetected := False;
      end;
    except
      raise;
    end;

  finally
    Locker.Leave;
  end;
end;

This little nugget very much bear the signs of being written for debugging, so I am not going to hold it to Kudzu for style (much). It includes a few nice examples of code that can be simplified, so it is all good.

So what do I do? • I assume the except block was for debugging, but I'm taking it out. • I might be changing the behaviour by setting two default values up top, but at least there is no doubt about their default value. • But what is with the conditional assignments? Please! BooleanVariable := Expression; !! Don't go "then true else false" on me! • Reworked the comments.

Personally, I think it is more readable like this.

procedure TReceiver.SetData(const Value: string);
var
  CRC16: Word;
begin
  fbNewMessage := False;
  TypeDetected := False;
  Locker.Enter;
  try
    fsData := Value;
    fiMsgLen := Length(fsData);
    if fiMsgLen > 0
    then begin // Data found, Check for Type
      Move(fsData[1], (pBuffer + fiPrenosLen)^, fiMsgLen);
      fiPrenosLen := fiPrenosLen + fiMsgLen;
      TypeDetected := (fiPrenosLen >= HeaderLen);
      if TypeDetected
      then begin // We have a type, check header for content
        Move(pBuffer^, Header, HeaderLen);
        fbNewMessage := Header.MsgLen <= fiPrenosLen;
        if fbNewMessage
        then begin  // we have enough data for the entire message
          MsgLen := Header.MsgLen - HeaderLen;
          Move((pBuffer+HeaderLen)^, Msg^, MsgLen);
          CRC16 := CRC16Calculator.HashValue(Msg^);  // Calculate the crc code
          fCRCFailed := CRC16 <> Header.CRC16;       // and check if it was correct
        end;
      end;
    end;
  finally
    Locker.Leave;
  end;
end;

Now, where is that flameproof tin foil dress...

Next: I'll be rambling a little more on effective comments, naming and structure.

Edit - added after Paul's Snippet Rewritten: Delphifreak likes to exit early. He also likes to initialize up top, and I totally agree - that is a good practice. Exit works well in this example where all the conditions are dependant on the previous one. IMO, things get a lot more hairy if there are multiple conditions with alternatives (if/then/else if). For this example, Exits are not bad.

procedure TReceiver.SetData(const Value: string);
var
  CRC16: Word;
begin
  fbNewMessage := False;
  TypeDetected := False;
  Locker.Enter;
  try
    fsData := Value;
    fiMsgLen := Length(fsData);
    if fiMsgLen = 0
     then Exit;

    // Data found, Check for Type
    Move(fsData[1], (pBuffer + fiPrenosLen)^, fiMsgLen);
    fiPrenosLen := fiPrenosLen + fiMsgLen;
    TypeDetected := (fiPrenosLen >= HeaderLen);
    if not TypeDetected
     then Exit;

    // We have a type, check header for content
    Move(pBuffer^, Header, HeaderLen);
    fbNewMessage := Header.MsgLen <= fiPrenosLen;
    if not fbNewMessage
     then Exit;

    // we have enough data for the entire message
    MsgLen := Header.MsgLen - HeaderLen;
    Move((pBuffer+HeaderLen)^, Msg^, MsgLen);
    CRC16 := CRC16Calculator.HashValue(Msg^);  // Calculate the crc code
    fCRCFailed := CRC16 <> Header.CRC16;       // and check if it was correct

  finally
    Locker.Leave;
  end;
end;

Writing Readable Code - Paul's Snippet - Show your formatting!

2008-08-15T06:31:00.002-07:00

Paul made an comment in my previous post, but unfortunately the Blogger comment system ate all the whitespace. Paul, if you read this - please reformat the code below and email it to me as a zipped attachment! I would also love to receive everybody else's reformatted version as well!
Your anonymity is guaranteed (Unless you explicitly permit me to name you and/or link to a site or something).

Please note that there was a syntax problem in the original snippet, and I have indicated that below. I suggest that unless Paul instruct us otherwise, we take out the semi-colon after the end on that line.


try
if ConditionA then
Code(1)
else if ConditionB then
if ConditionC then begin
if ConditionD then
code(2);
code(3);
end; // I assume this semi-colon has to go
else if ConditionE then begin
code(4);
morecode('X');
if ConditionF then
code(5)
else if ConditionG then
code(6);
end else begin
code(7);
morecode('Y');
end;
finally
code(8);
end;

Writing readable code - Comment for Context

2008-08-15T06:31:00.001-07:00

While waiting for more suggestions to Paul's snippet, and while weaving and dodging through the virtual fireballs from the previous posts on code formatting and comments, I fearlessly continue my Don Quixote Crusade for readable code. I am not quite done with comments yet.

It is said that "Real programmers don't write comments - It was hard to write - it should be hard to read". That doctrine is way overdue for deletion.

Comments are the context frame of our code.

Comments are like garlic.
Too little and the result is bland and unpalatable, too much and it stinks things up. Comments should only in rare occasions assume that the reader is too dumb to read the code properly, so as a general rule - we should not rewrite our code in plain english, line for line. Such an approach tend to fog up [sic] the source, and it becomes a drag to maintain (Yeah, I know... garlic metaphors stink...).

Comments are like news headlines.
// File ready for saving!
// No more filehandles, says OS
// Raises exception for World+dog
They should be short, concise and to the point. In good tabloid tradition, they should also only touch on the very general points, and oversimplifying what really is going on.

Comments are like foreplay.
They serve to get us readers in the mood to appreciate the sleek lines, the richness of it's properties, and possibly arouse our interest to the point where we are ready to ravage the code.

Comments are like, bi-se... uh directional.
Err, well ... what I am trying to say is that sometimes we can write them before we do stuff, while at other times - it can be just as effective to write them after something has been done in the code. The first would probably indicate how we are going to do something, while the latter would focus on the result of what we just did.

Pick up the garbage!
Do you leave your workshop tools lying about in case you need them quickly, or do you store them safely away? Once you finalize your code, clean it up. Put "I deleted this, moved that, added that" comments in your version control commit/check-in comments, and don't litter the source code with it. Once the code has been created or removed, the reason is uninteresting. What the code is supposed to do, is so much more valuable information. Remove unnecessary comments.

Don't spread FUD.
Your commentary should embellish the correctness and function of your code, not underline how insecure, unexpectedly behaving, mysterious, or potentially unreliable code it is. If there is remaining work to be done, that should be written as a To-Do point, containing sufficient information to guide you to a starting point for that work.

It takes practice to write good commentary (life-long practice, some would say), but unless your code is totally clear and unambiguous to the point of self-explaining to your grandmother, you should probably add some comments.

To round it off, here are a couple of disturbing - but funny - comments I have come across in production code:


// ---- Better let sleeping dogs lie? Note the date. ----

  try
    if ValidParentForm(self) <> nil then
    begin
      ValidParentForm(Self).ActiveControl:=NIL;
      //Turn this back on when I return from my holiday and have time to test it 
      //N.N. 20.07.2001
      {if ValidParentForm(Self).ActiveControl=lFocusedControl then
        //Control doesn't let go of focus, most likely because of some error message
        exit; //Aborting the routine}
    end;
    if DataSet is TExtendedDataSet then
      TExtendedDataSet(DataSet).Save
    else
      DataSet.Post;
  finally
    . . .

// ---- Unusual if/then/else construct ----

   if  (EditSomeProp.Text <> '')
   and ((RequestTable[i].NUMREF+1) > StrToInt(EditSomeProp.Text)) then
   // Watch out for Elsie here
   else
   begin
     . . .

Should I or should I not uncomment the first comment? Well, it has been inactive for 7 years, so I think I'll leave it as is, or remove it.
The second one is history, due to a rewrite.

Writing Readable Code - Paul's Snippet Rewritten

2008-08-15T06:31:00.000-07:00

Five brave people have contributed rewritten versions of Paul's code. Let's take a look at their approach.

I reformatted Paul's example using two spaces for every indent level (after then, begin, else, etc. ), hoping that this is the way he originally wrote it.

IMO, Paul's formatting (or my assumptions about his formatting) does not reflect the true code path, and trying to decipher the code paths become unnecessarily hard.

  try
    if ConditionA then
      Code(1)
    else if ConditionB then
      if ConditionC then begin
        if ConditionD then
          code(2);
        code(3);
      end
    else if ConditionE then begin
      code(4);
      morecode('X');
      if ConditionF then
        code(5)
      else if ConditionG then
        code(6);
    end else begin
      code(7);
      morecode('Y');
    end;
  finally
    code(8);
  end;

Here is a small exercize. If we say that the string "ABCDEFG" are all conditions TRUE, and the string "abcdefg" are all conditions false:
• What codes are run by "ABCDEFG"?
• What codes are run by "aBcdefg"?
• What string(s) would make code(6) run?

TS contributed a very nicely formatted version, which is effective in guiding us through the potential code paths. I like his style.

  try
    if ConditionA then
      Code(1)
    else if ConditionB then
      if ConditionC then
      begin
        if ConditionD then
          code(2);
        code(3);
      end // without the semi-colon
      else if ConditionE then
      begin
        code(4);
        morecode('X');
        if ConditionF then
          code(5)
        else if ConditionG then
          code(6);
      end
      else
      begin
        code(7);
        morecode('Y');
      end;
  finally
    code(8);
  end;

SS didn't quite manage to reflect the flow in the code and his formatting is similar to Paul's code.

  try
    if ConditionA then
      Code(1)
    else if ConditionB then
      if ConditionC then
      begin
        if ConditionD then
          code(2);
        code(3);
      end //; I assume this semi-colon has to go
    else if ConditionE then
    begin
      code(4);
      morecode('X');
      if ConditionF then
        code(5)
      else if ConditionG then
        code(6);
      end
    else
    begin
      code(7);
      morecode('Y');
    end;
  finally
    code(8);
  end;

Jolyon scores high on restructuring and simplifying, but he made one mistake in his change. Under which condition will his code behave differently form the original?

  procedure WhenC;
  begin
    if ConditionD then
      code(2);
    code(3);
  end;

  procedure WhenE;
  begin
    code(4);
    morecode('X');
    if ConditionF then
      code(5)
    else if ConditionG then
      code(6);
  end;

begin
  try
    if ConditionA then
      Code(1)
    else if NOT ConditionB then
      EXIT;

    if ConditionC then
      WhenC
    else if ConditionE then
      WhenE
    else
    begin
      code(7);
      morecode('Y');
    end;
  finally
    code(8);
  end;

AO goes even further than Jolyon in reformatting and comments: As I believe that proper formatting is not the only way to increase readability of code, I also refactored it a bit to reduce nesting where possible. If this were an actual code, I would have probably gone even further and introduced separate routines for the individual blocks, depending on their complexity.

  try
    { This comment explains why ConditionA is handled first. }
    if ConditionA then begin
      Code(1);
      Exit;
    end;
  
    { This comment explains why the aggregate of ConditionB and ConditionC is handled next. }
    if ConditionB and ConditionC then begin
      { This comment explains why ConditionD is relevant only in this block. }
      if ConditionD then
        code(2);
  
      code(3);
      Exit;
    end;
  
    { This comment explains why ConditionE is handled next. }
    if ConditionE then begin
      code(4);
      morecode('X');
  
      { This comment explains why ConditionF and ConditionG are relevant only in this block. }
      if ConditionF then
        code(5)
      else if ConditionG then
        code(6);
  
      Exit;
    end;
  
    { This comment explains the default handling. }
    code(7);
    morecode('Y');
  finally
    { This comment explains why the following code must execute no matter what. }
    code(8);
  end;

This is readable, but personally I think AO went a bit too far. Like Jolyon, he also missed a structural detail in the refactoring and broke the code. Which condition state(s) will cause the code to misbehave?

I am divided on the use of Exit. It can add clarity, but it can also be a big problem as you leave a lot of code "dangling". If you decide to move the exit - you have to be really careful to ensure that any states that suddenly move in or out of scope behave correctly. If there is a nesting church and a chunking church, I'm probably a "Nestorian".

I do agree that refactoring is a valuable tool to clarify and simplify, and we should make an effort to break down our code into manageable blocks, but in this particular case it probably isn't necessary.

Another thing: I avoid using {curly braces} for in-code commentary and use // instead. Why? Because if you need to comment out code containing select count(*) from table, those curlies will work where the (* comment *) fail. Should CodeGear add support for comment nesting? I don't know...

Anyways...
Here's how I would format the example. This is very similar to TS's example, except that I showel all the reserved words to the left side to leave the logic more visible and commentable, but I also add indentation to the innermost conditional code.

  try
    if ConditionA
     then Code(1)
     else if ConditionB
      then if ConditionC
       then begin
         if ConditionD
          then code(2);
         code(3);
       end
       else if ConditionE
        then begin
          code(4);
          morecode('X');
          if ConditionF
           then code(5)
           else if ConditionG
            then code(6);
        end
        else begin
          code(7);
          morecode('Y');
        end;
  finally
    code(8);
  end;

MJ adds a contribution with the following comment: "To be sure not to create any future bugs you should consider adding a begin end section after every if statement even if it is not required, but that will make the code more unreadable."

  try
    if ConditionA then
      Code(1)
    else if ConditionB then
    begin
      if ConditionC then
      begin
        if ConditionD then
          code(2);
        code(3);
      end
      else if ConditionE then
      begin
        code(4);
        morecode('X');
        if ConditionF then
          code(5)
        else if ConditionG then
          code(6);
      end
      else
      begin
        code(7);
        morecode('Y');
      end;
    end;
  finally
    code(8);
  end;

Good Points! In all honesty, I also screwed up the code blocks on first try. Conditional code will bite you if you are not very very careful. You should indeed think about what may happen if you need to add more code and/or conditions. Personally, I don't think a few more enclosures makes the code less readable. Here is how I would be more explicit in the use of enclosures to make the code less ambiguous.

  try
    if ConditionA
     then Code(1)
    else begin
      if ConditionB
      then begin
        if ConditionC
        then begin
          if ConditionD
           then code(2);
          code(3);
        end
        else begin
          if ConditionE
          then begin
            code(4);
            morecode('X');
            if ConditionF
             then code(5)
             else if ConditionG
              then code(6);
          end
          else begin
            code(7);
            morecode('Y');
          end;
        end;
      end;
    end;
  finally
    code(8);
  end;

There is no one true correct way of formatting.
The point I am trying to make is that code structure matter for understanding the code at first glance, and we should be mindful about how we lay it out. We should strive for consistency, but always keep clarity and unambiguity as priority one. Bend your rules, if you need to.

Paul, Thank you for creating such a devious code snippet!

P.S. If you haven't figured out the answers yet, load up your Delphi and run all the examples in StructureDemo.dpr.
No peeking until you have some suggestions! :)
(Hint: else starts a new block)

Edit: Added an example of using Exits instead of nesting to the initial post on formatting. It would be interesting to see DelphiFreak have a go at Paul's snippet.

Latest Tiburón Preview

2008-08-13T18:31:00.008-07:00

I was a little disappointed that the preview webinar this morning was little more than a re-run of the same content from a little over a week ago, albeit with some downloadable PowerPoint slides this time.

It was at least an opportunity for some more Q&A and a couple of interesting Q’s got A’d.

1. Generics Support For Event Types

In my series of posts on multicast events I speculated that if generics support included using event types as parameters then things could be made a little easier. David I demonstrated that it does appear to be possible:

  TEventList = TList<TNotifyEvent>;

So it appears that in a future D2009 revision of my multicast events implementation we should be able to write:

  TMultiCastNotify = TMultiCast<TNotifyEvent>;

It won’t, as far as I can tell, eliminate all the work in deriving a new multicast event class, but it will remove the drudgery of implementing Add() and Remove() methods, at the very least.

2. Release Timeframe

In response to the inevitable questions about when it (Delphi 2009) will be released, the stock response is still “When it’s ready“. The supplemental question “When will it be ready?” triggered a stack overflow exception:

Q. When will it be ready?

A. When it’s ready.

Q. Cool, so when will it be ready?

A. When it’s ready.

etc

However, it was mentioned that these preview webinars will continue on a weekly basis through to the end of September. So I think it’s not unreasonable that we might optimistically hope for an October timeframe for an actual release.

3. Ribbon is Not Entirely VCL Code

At the previous preview I got the distinct impression that the ribbon control support was entirely CodeGear VCL code. This time around it was mentioned that it is a VCL wrapper around Microsoft code. I’m not sure that this is particularly important one way or the other, but some people might find it interesting.

Update: Nick Hodges (Delphi Product Manager, so he should know) has clarified that there is in fact no wrapper or Microsoft code involved, only VCL code.

What was certainly interesting was the indication that if you use the ribbon control in an application then you will need to obtain a ribbon UI license from Microsoft to then deploy that application.

This in itself is already controversial and one school of thought has it that the license is not only undesirable, but quite possibly unenforceable.

4. No Generics Enrichments in the VCL

Apart from the Generics.Collections support, the VCL itself has not been enriched with generics support. I find this surprising. It strikes me that it should have been quite straightforward to enable us to write:

TCustomerComboBox = TComboBox<TCustomer>;

To create type-safe access to the data associated with the items in a combobox, for example.

It should be relatively easy to create these extensions ourselves, but it would have been nice to have that support built in to the VCL. Having said that, design-time support would have been a bit difficult I suppose. i.e. dropping a regular combo-box on a form and then specifying the type of the items data via the property inspector.

5. Insight Into the Interested Customer Base

Aside from the information on Tiburon itself, the QA provided an interesting insight into the parts of the community that are actively interested in Delphi 2009. Some of the questions appeared to demonstrate a lack of familiarity with more recent changes in the language, such as support for dotted unit names (Delphi 7) and strict private visibility (Delphi 2006, I think).

I am not ridiculing the people that asked those questions. Far from it. I think it is positively encouraging that users who - it would appear - were perhaps previously “left behind” are once again interested in this new version of Delphi.

It reinforces a general impression that I am increasingly forming, that a new spark of life has appeared in the Delphi community.

More To Come

As mentioned, it appears there will be more previews to come, on a weekly basis. The schedule currently only runs to the end of August, not September, but whether David I misspoke or the full schedule simply isn’t finalised yet, I don’t know.

For local visitors, the 11am PDT time slot is 6am the following day in “Auckland Time”.

The future is bright. The future is Delphi.

Keyword

Delphi

Vonage calling from ObjectPascal

2008-08-13T18:31:00.007-07:00

Last week, a customer asked if he could call using his Vonage phone to call from an application I developed some time ago. After searching for a way to do this, I stumbled upon this tutorial, then adapted the examples to ObjectPascal.

The results

The first problem I found was how to connect to an HTTPS site. Of course the answer was Synapse with the help of OpenSSL libraries.

I created couple of small functions that first log in to a Vonage account, then place the call. The functions are contained in this unit:

unit vonagecall;

interface

(* Calls to Vonage phone *)
function CallToVonage(AUserName, APassword, AFromNumber, AToNumber: string): string;

implementation

uses
  Classes,
  ssl_openssl,
  httpsend;

function GetVonageNumbers(AUserName, APassword: string): string;
(* This function must be allways called from CallToVonage *)
var
  lHttp: THTTPSend;
  lParams: string;
  lResponse: TStringStream;
begin
  Result := '';
  lHttp := THTTPSend.Create;
  lResponse := TStringStream.Create('');
  try
    lParams := 'username=' + AUserName;
    lParams := lParams + '&password=' + APassword;
    (* Get Phone numbers *)
    lHttp.HTTPMethod('GET', 'https://secure.click2callu.com/tpcc/getnumbers?' + lParams);
    lHttp.Document.SaveToStream(lResponse);
    Result := lResponse.DataString;
    if Pos(':', Result) > 0 then
      Result := 'Failed to retrieve Vonage phone numbers. Check your username and password.';
  finally
    lResponse.Free;
    lHttp.Free;
  end;
end;

function CallToVonage(AUserName, APassword, AFromNumber, AToNumber: string): string;
(* This makes the real call *)
var
  lHttp: THTTPSend;
  lParams: string;
  lResponse: TStringStream;
begin
  Result := '';
  lHttp := THTTPSend.Create;
  lResponse := TStringStream.Create('');
  try
    lParams := 'username=' + AUserName;
    lParams := lParams + '&password=' + APassword;
    lParams := lParams + '&fromnumber=' + AFromNumber;
    lParams := lParams + '&tonumber=' + AToNumber;
    GetVonageNumbers(AUserName, APassword);
    lHttp.HTTPMethod('GET', 'https://secure.click2callu.com/tpcc/makecall?' + lParams);
    lHttp.Document.SaveToStream(lResponse);
    Result := lResponse.DataString;
  finally
    lResponse.Free;
    lHttp.Free;
  end;
end;
end.

The unit requires you to deploy libeay32.dll and ssleay32.dll, you can download these files from OpenSSL.org project. There are Windows and Linux versions.

To use it, just include the vonagecall unit in the uses of your program and call the function CallToVonage passing UserName, Password, FromNumber and ToNumber parameters.

In this zip file, I packaged everything you need to test the function.

Hasta la próxima!

Developing Office Add-ins the Easy Way - Part 2 of 2 (AKA: The tutorial stuff...)

2008-08-13T18:31:00.006-07:00

If you haven't read Part 1, I'd advise you to do so. In it you'll find some more information on these components and, more importantly, your 20% discount coupon redeemable until the end of June 2007...

Step 1: Running the new Add-In Wizard

Fire up Delphi and choose File->New->Other, Delphi Projects->Add-In Express VCL->ADX Outlook Add-in.
Click Next and, for the project name, I'm using Insider and coInsider for the coClass Name. The first is used, guess what?, for the Project's name and the 2nd is used in Outlook's COM Addins dialog (Tools->Options->Other->Advanced Options)
Clicking next will show you the "Option Pages" step which is optional.
- For this addin we'll just hit next again. For a more complex add-in, this would be where you'd create your own option pages. You can have option pages displayed as another tab on the Options dialog or by right-clicking all or some folders in outlook, say one for Inbox, other for Outbox: they are different types of dialogs serving different purposes and you can add as many as you like.
Hit next again and we'll be in the "Outlook 2007 Task Panes"; again, not of interest to us here so move along.
Click Next, Finish and we're done here.

Step 1.5: More blah, blah, blah...

We now have a basic project that we'll add some meat to in order for it to do what we set out to. We could easily add an explorer or inspector command bar, but we don't need them for this project. An explorer command bar is one that is displayed on Outlook; an inspector command bar is displayed when you double-click some outlook item and "inspect" it in it's own window. Say, when you double click an e-mail message and another window pops up. You can have the inspector command bars only display for certain types of folders by simply setting a property, say, create an e-mail inspector bar that is displayed only when inspecting a mail message but not when viewing an appointment. And, of course, you can add as many as you want and add buttons, menus and other controls to them at will.

Among other cool objects you can use (not needed for this add-in), are the TADX<AppNameHere>AppEvents, such as TADXOutlookAppEvents from where you can add your own handlers. Here's the list of OutlookAppEvents (these are global events: other components have their own events as well, but these are events that don't relate to a particular button being pressed or hotkey being used):

OnItemSend
OnNewMail
OnNewMailEx
OnQuit
OnReminderFire
OnStartup

BTW: Thanks to blogger messing up my formatting big-time, I had to shorten the list to just a few sample items so as not to have a whole lot of space wasted. Maybe I'll take a prt-scr later and update this...

Step 2: Adding some components and code

What we are now going to add is an "ADX Outlook Form" which is a small pane where we will be displaying the headers of the selected message, so go to File->New->Other, Delphi Projects->Add-In Express VCL and double click "ADX Outlook Form".
Save the form (I used uHeader for the unit name).
Add a TListBox, call it lbxHeader and set it to fill the form.
We need another component to control creation of these panes. Go on to the main project form (should be empty) and add a "TadxOlFormsManager".
In this component's events, add the following code to the "OnADXBeforeFormInstanceCreateEx" event:
```
1 if args.FolderObj.EntryID = OutboxEntryID then begin
2   args.Cancel := true;
3 end;
```
Let's add that OutboxEntryID as a protected property to the form (TAddInModule) of type string:
```
1 property OutboxEntryID: string read FOutboxEntryID;
```
And the corresponding internal field to the private section of TAddInModule:
```
1 FOutboxEntryID: string;
```

And a method to set the value in the protected section (not a setter method though!):

 1 procedure SetOutboxEntryID;
 2 
 3 procedure TAddInModule.SetOutboxEntryID;
 4 var
 5   nameSpace   : Outlook2000.NameSpace;
 6   outboxFolder: Outlook2000.MAPIFolder;
 7 begin
 8   try
 9     nameSpace      := OutlookApp  .GetNamespace    ( 'MAPI'         );
10     outboxFolder   := nameSpace   .GetDefaultFolder( olFolderOutbox );
11     FOutboxEntryID := outboxFolder.EntryID;
12   finally
13     nameSpace    := nil;
14     outboxFolder := nil;
15   end;
16 end;

Now click the form and enter the following code to it's "OnAddInInitialize" event:
```
1 SetOutboxEntryID();
```
Finally, let's give the TadxOlFormsManager something to manage: double click it and add a new item. Set the following properties for that item:

ExplorerItemTypes->expMailItem, set to True as we want this form displayed on mail folders only; leave all others to false.
ExplorerLayout set to elTopSubpane; (you can play around with it later if you want!)
And finally, let's link it to the form we created above: set FormClassName to our form created above. It will be available on the drop down as soon as you go into File->Use Unit and select our uHeader unit.

If you build the project, register it and launch outlook, you'll see a blank new pane displayed: Sorry for the large, dimmed and blurred image: it's from my main outlook... :)

Also, if you notice, so far most of the code was related to adding an exception, that is, we wanted our form to display on mail folders, unless that folder is Outbox.

Now it's time to add our real meat into this.

Step 3: Adding our application logic

Lets go back to our uHeader unit and add the following code to the onADXSelectionChange event:

 1 procedure TfrmHeader.adxOlFormADXSelectionChange( Sender: TObject );
 2 var
 3   Selection: Outlook2000.Selection;
 4   IMail    : _MailItem;
 5   IMessage : MAPIDefs.IMessage;
 6   PropValue: PSPropValue;
 7 begin
 8   lbxHeader.Items.Clear;
 9   Selection := Self.ExplorerObj.Selection;
10   IMail     := nil;
11   if Selection.Count > 0 then begin
12     try // Try for a "normal" mail item
13       Selection.Item(1).QueryInterface( IID__MailItem, IMail );
14       if not Assigned( IMail ) then begin
15         // If it failed, try for a Read/Delivery Receipt item
16         Selection.Item(1).QueryInterface( IID__ReportItem, IMail );
17       end;
18       if not Assigned( IMail ) then begin
19         // I don't use Remote Mail, but for completeness this should be tested also...
20         Selection.Item(1).QueryInterface( IID__RemoteItem, IMail );
21       end;
22     except// Ignore exceptions
23       // QueryInterface may throw up an exception, but I don't recall under what condition it was
24       // It was for some non->relevant item, i.e., one that we're not processing here
25       // That's the bad thing of writing something and not documenting it properly when it happens!
26     end;
27     if Assigned(IMail) then begin
28       try
29         if IMail.Sent then begin
30           IMail.MAPIOBJECT.QueryInterface(MapiDefs.IMessage, IMessage);
31           if Assigned(IMessage) then begin
32             try
33               PropValue := nil;
34               if HrGetOneProp(IMessage, PR_TRANSPORT_MESSAGE_HEADERS, PropValue) = S_OK then begin
35                 StringToList( PropValue^.Value.lpszA, lbxHeader.Items );
36               end;
37             finally
38               MAPIFreeBuffer(PropValue);
39               IMessage := nil;
40             end;
41           end;
42         end;
43       finally
44         IMail := nil;
45       end;
46     end else begin // If no headers found...
47       lbxHeader.Items.Add( 'This type of message does' );
48       lbxHeader.Items.Add( 'not have mail headers' );
49     end;
50   end;
51 end;

Now let's add the MAPI units to our project and to the uses clause in this form:
```
1 uses MapiDefs, MapiTags, MAPIUtil;
```

Now all that is left is to add that StringToList function I used to process the semi-colon formatted mail headers into a more readable list:

 1 procedure StringToList( Str: string; lstResult: TStrings );
 2   // Convert a header string containing CR/LFs and TABs into
 3   // a stringlist where each new property starts on a new line
 4 var
 5   iPos : integer;
 6 const
 7   CRLF = #13#10;
 8 begin
 9   lstResult.Clear;
10   iPos := Pos( CRLF, Str );
11   while (iPos > 0) and (iPos < (Length( Str )-1) ) do begin
12     // If the new line starts with a Space or Tab, it's a continuation line
13     if (Str[iPos+2] = #9) or (Str[iPos+2] = #32) then begin
14       Delete( Str, iPos, 2 );
15     end else begin
16       lstResult.Add( Copy( Str, 1, Pred(iPos) ) );
17       Delete( Str, 1, Succ( iPos ) );
18     end;
19     iPos := Pos( CRLF, Str );
20   end;
21 end;

And we're done!

Just build again, and re-launch outlook and you'll have something like this:

Final thoughts and notes:

Don't forget that you can regsvr32 dlllname.dll or regsvr32 -u dllname.dll and any installer will do that for you if you mark the dll as self-registering.
Don't forget that you'll need to close the application you're testing/compiling your add-in for, before you can compile it as the dll will be in use! :)
If you look back, you'll see that you pratically never knew you were handling COM objects and that most of the code was for the application logic with part of the complexity in that arising from using Extended Mapi because Outlook's object model is a bit limited in some places... Creating Excel add-ins is even easier as you don't have to deal with Extended Mapi! ;) You will require some knowledge of the application's Object Model, but that comes out of the box in the form of some VBA help files that you can install with your Office.
I didn't show in this simple demo two other easy to implement features, mostly out of lazyness: adding toolbars/buttons/menus and option pages. Trust me (or don't trust and instead try for yourself!): those are very easy to implement!
Don't forget to take advantage of the 20% discount coupon (see Part 1), and have fun Developing Office Add-ins the Easy Way!
Syntax highlighting done using Steve Trefethen's Syntax Highlighter and then manually tweaked the generated HTML to fix some coloring bugs.

Help needed with PDF Processing Library...

2008-08-13T18:31:00.005-07:00

After two days of searching, clicking through hundreds of links, downloading tens of files, trying, browsing, etc, I decided it was about time to give up and ask for help!

I need to process some PDFs, mostly "black-and-whitening" them, that is, converting color boxes and text into black and white. It's not the same as "printing" in black and white though, as I want to replace boxes filled with some color with ones with no color fills and change the corresponding white or light colored text with black text.

Example:

From this: to this:

I'd like to do this in Delphi, but I can do in a million other languages such as Perl, PHP, Python, Java, C# or whatever. I have one restriction though: the library has to be either free or open-source, but this restriction can be waived if there's nothing free or open-source that I can use to solve the problem...

Does anyone know of a library that will allow me to do that? Open a PDF file, loop through all the objects and change characteristics as I see fit, and finally saving the edited file

If you know such a library/tool, please leave a comment... Thank you.

Holidays

2008-08-13T18:31:00.004-07:00

Anyone else out there ever run into the need for a simple little list of holidays? I do a fair amount of stuff that involves questions like "Are we off on such and such a day?" where you have to figure out, "When is Easter this year anyway?" That's pretty easy if you look it up on a calendar. Now try doing that in code.

At any rate, I wrote a tiny little class to provide some basic holidays out. Help yourself to the code, it's not complicated, just annoying. The biggest trick is finding the information in the first place. This is US-oriented, but I'd be glad to extended it if someone wants some other days in there. It would be helpful if you could provide the holiday information you're interested in though (i.e., My Personal Holiday is the 3rd Tuesday of May or whatever). Oh, one last caveat. If the date doesn't appear (like Inauguration day), the DateTime will be a 0. That's fine for comparisons, but if you just do a dump of the dates, it gives you 1899.


unit holidayDateTime;

interface

uses sysutils;

type
   THolidayClass = class
     public
        YearIs       : word;
        NewYears     : TDateTime;
        MLKJr        : TDateTime;
        Inauguration : TDateTime;
        Washington   : TDateTime;
        ArmedForces  : TDateTime;
        Memorial     : TDateTime;
        FlagDay      : TDateTime;
        Independence : TDateTime;
        Labor        : TDateTime;
        Columbus     : TDateTime;
        Veterans     : TDateTime;
        Thanksgiving : TDateTime;
        Christmas    : TDateTime;
        Secretaries  : TDateTime;
        AprilFools   : TDateTime;
        Earth        : TDateTime;
        Fathers      : TDateTime;
        Groundhog    : TDateTime;
        Halloween    : TDateTime;
        Lincoln      : TDateTime;
        Mothers      : TDateTime;
        StPatty      : TDateTime;
        UnitedNations: TDateTime;
        Valentines   : TDateTime;
        Election     : TDateTime;
        Flag         : TDateTime;
        Easter       : TDateTime;
        constructor Create(aYear:word);
        procedure changeYear(aYear:word);
        function getEaster:TDateTime;
        class procedure SafeMonth(var month, y:word);
        class function getDOW(year, month, dow, weekNum:word):TDateTime;
        class function getLastDOW(year, month, dow:word):TDateTime;
     end;

implementation

class procedure THolidayClass.SafeMonth(var month, y:word);
begin
while month>12 do
   begin
   dec(month,12);
   inc(y);
   end;
end;

class function THolidayClass.getDOW(year, month, dow, weekNum:word):TDateTime;
var i:word;
begin
result:=EncodeDate(year, month, 1);
for i:=0 to 7 do
   if DayOfWeek(result+i)=dow then
      begin
      result:=result+i;
      result:=result+((weeknum-1)*7); //move to the correct week, 1st week is inc of 0
      break;
      end;
end;

class function THolidayClass.getLastdow(year, month, dow:word):TDateTime;
var i:word;
begin
//Year has to be on the stack, SafeMonth could change year
inc(month);
SafeMonth(month,year);
result:=EncodeDate(year,month,1)-1;
for i:=0 to 7 do
   if DayOfWeek(result-i)=dow then
      begin
      result:=result-i;
      break;
      end;
end;

constructor THolidayClass.Create(aYear:word);
begin
ChangeYear(aYear);
end;

function THolidayClass.getEaster:TDateTime;
var a,b,c,d,e,f,g,h,i,k,l,m,p  : integer;
    Easter_Month, Easter_Day   : integer;
begin
   a:=yearis mod 19;
   b:=yearis div 100;
   c:=yearis mod 100;
   d:=b div 4;
   e:=b mod 4;
   f:=(b+8) div 25;
   g:=(b-f+1) div 3;
   h:=(19*a+b-d-g+15) mod 30;
   i:=c div 4;
   k:=c mod 4;
   l:=(32+2*e+2*i-h-k) mod 7;
   m:=(a+11*h+22*l) div 451;
   Easter_Month :=(h+l-7*m+114) div 31; //[3=March, 4=April]
   p:=(h+l-7*m+114) mod 31;
   Easter_Day:=p+1; //(day in Easter Month)
   result:=EncodeDate(YearIs,Easter_Month,Easter_Day);
end;


procedure THolidayClass.ChangeYear(aYear:word);
const
   DayOfWeek_Sunday    = 1;
   DayOfWeek_Monday    = 2;
   DayOfWeek_Tuesday   = 3;
   DayOfWeek_Wednesday = 4;
   DayOfWeek_Thursday  = 5;
   DayOfWeek_Friday    = 6;
   DayOfWeek_Saturday  = 7;

begin
YearIs       := aYear;
Easter       := getEaster;
NewYears     := EncodeDate(YearIs,1,1);
MLKJr        := getdow(YearIs, 1, DayOfWeek_Monday, 3);
if (YearIs - 1937) mod 4 = 0 then
   Inauguration := EncodeDate(YearIs, 1, 20)
else
   Inauguration := 0;
Election     := 0;
Flag         := EncodeDate(YearIs,6,14);
Washington   := getdow(YearIs, 2, DayOfWeek_Monday, 3);
ArmedForces  := getdow(YearIs, 5, DayOfWeek_Saturday, 3);
Memorial     := getLastdow(YearIs, 5, DayOfWeek_Monday);
FlagDay      := EncodeDate(YearIs,6,14);
Independence := EncodeDate(YearIs,7,4);
Labor        := getdow(YearIs, 9, DayOfWeek_Monday,1);
Columbus     := getdow(YearIs, 10, DayOfWeek_Monday,2);
Veterans     := EncodeDate(YearIs,11,11);
Thanksgiving := getdow(YearIs, 11, DayOfWeek_Thursday,4);
Christmas    := EncodeDate(YearIs,12,25);
Secretaries  := getLastdow(YearIs, 5, DayOfWeek_Saturday) - 3; //wednesday before last saturday in april
AprilFools   := EncodeDate(YearIs,4,1);

Earth        := EncodeDate(YearIs,4,22);
Fathers      := getdow(YearIs, 6, DayOfWeek_Sunday,3);
Groundhog    := EncodeDate(YearIs,2,2);
Halloween    := EncodeDate(YearIs,10,31);
Lincoln      := EncodeDate(YearIs,2,12);
Mothers      := getdow(YearIs, 5, DayOfWeek_Sunday,2);
StPatty      := EncodeDate(YearIs,3,17);
UnitedNations:= EncodeDate(YearIs,10,24);
Valentines   := EncodeDate(YearIs,2,14);
end;

end.

Detecting Virtual PC

2008-08-13T18:31:00.003-07:00

Adding to my previous post on detecting virtual environments, here's the code for detecting Virtual PC. Note that it's a conversion from CodeProject, the original author is here. I also didn't write the conversion, I'm simply accumulating the VMM detection code here. Original credit for the conversion goes to Dennis Pasamore who did the bulk of the conversion work with some assistance from Avatar Zonderatau.

Code:


function TForm1.IsRunningVirtualPC: boolean;
asm
  push ebp;
  mov ebp, esp;

  mov ecx, offset @exception_handler;

  push ebx;
  push ecx;

  push dword ptr fs:[0];
  mov dword ptr fs:[0], esp;

  mov ebx, 0; // Flag
  mov eax, 1; // VPC function number

  // call VPC
  db $0F, $3F, $07, $0B

  mov eax, dword ptr ss:[esp];
  mov dword ptr fs:[0], eax;

  add esp, 8;

  test ebx, ebx;

  setz al;

  lea esp, dword ptr ss:[ebp-4];
  mov ebx, dword ptr ss:[esp];
  mov ebp, dword ptr ss:[esp+4];

  add esp, 8;

  jmp @ret1;

@exception_handler:
  mov ecx, [esp+0Ch];
  mov dword ptr [ecx+0A4h], -1; // EBX = -1 ->; not running, ebx = 0 -> running
  add dword ptr [ecx+0B8h], 4;  // ->; skip past the call to VPC
  xor eax, eax;                 // exception is handled

@ret1:
end;

Reputation vs The Resume

2008-08-13T18:31:00.002-07:00

I have spent a good part of my professional career as a contractor so I was interested when I came across a post titled "Why bother having a resume?" on a blog site by Seth Godin. Seth gives an interesting argument that looks at the resume in 2 distinct ways: firstly he suggests that if you have a good reputation, then you won't need a resume; and secondly, that resumes are used by agents and employers in order to reject the bulk of respondents to get down to the interesting few they want to look at.

I partially agree with Seth on both counts, however experience suggests caution on either front. During the 1990's I was lucky enough to have so many offers for contract work that I could take my pick. Companies were falling over themselves to offer me a contract because I had the distinct advantage of having built up a good reputation in the IT industry here.

That no longer occurs, so what happened? Did my reputation go bad? No, I am still relatively well known and my reputation has not suffered. Did the job industry dry up? No again, although there are now many more applicants to choose from. The answer to this is much more involved and we have to look at a little history to see what went wrong in the industry here.

Prior to 2000, there was so much panic over the "millennium bug" that anyone who could spell IT was employed in the industry as a Y2K consultant - not much more technical expertise, or even very much in the way of IQ was required. Once the year 2000 came and went without the predicted worldwide mass destruction, the wonderful Y2K pig trough was taken away and hundreds of thousands of "IT Experts" were out on the street looking for new jobs. A short time later 9/11 hit the whole world (my brother was stuck in Hawaii, cursing that the late arrival of his plane from Malaysia meant that he had missed his connecting flight to be at a meeting planned for 9am near the top of one of the towers). Every IT project in New Zealand just suddenly dried up. This also meant that thousands more IT people, this time mostly good, experienced and employable IT people, were out on the street applying for any IT job available.

Companies and IT job agencies suddenly found themselves with a problem. For each IT job they advertised, they would get hundreds of applicants. Looking through all those CV's for a half decent applicant to consider was a nightmare. Companies that used to do all the hiring themselves, now started to put into place a "Policy". For those initiated into the secret language of corporates, a "Company Policy" is a proclamation that is set permanently into the steel frame girders of the head office and emblazoned across the foreheads of all General Managers and others who sometimes think they are in charge. This particular policy states, "No longer can a manager employ staff on their own but must go though an employment agency".

The reasoning was sound to begin with. Agencies could sift through the hundreds of applications and forward to them only the few that would be suitable for the role they wanted to fill. Reality however was much bleaker than the rosy view they were sold. What tended to happen was that the agencies, in an effort to cope with the influx of applicants, started hiring new, young people who were then tasked with the job of sifting the applications. I do know of agencies (or I should say "agents") who would, and still do, simply go through the first applications until they have two candidates that sound like they could do the job, then look no further (i.e. hundreds of job applications were never even opened), then forward those two to the client. Most however instigated the process of elimination that Seth talks about. This followed a simple process whereby firstly they would take out only those applications that had a university degree or higher, then go through those taking out only those who's current role was the same as, or similar to the role they are trying to fill. Only then, when they were down to a small hand full, would they actually look at the names and history of those that they had picked.

Even ringing the agents that I had built up a good friendship and reputation with was fraught with difficulty during the next 5-6 years. To protect themselves from the pleading masses, they had to resort to employing gate-keepers. These gate keepers would only let through people who were either the companies they dealt with, or the named people that had been selected from the process of elimination. The gate-keepers cared not for reputation and had heard before the pretentious arguments that they were somehow "long lost friends" of the employment agent in charge.

No job I applied for was going to even see my name unless by some pure fluke, I got through the process of elimination. My excellent reputation built with sweat and blood and now meant diddly-squat - the resume was king. Only of you were one of the first 20 who applied for the role, had a Masters degree from a known university, and had been doing that specific role for the past 5 years would you be deemed competent enough to have your name looked at.

Although the agencies have relaxed their stance somewhat, and I can again speak directly to the agent in charge, don't forget the power of the resume. Also don' forget the all important qualifications - even with my industry recognition and reputation I had to go back to university to gain qualifications enough to pass through "the process".

With recession noises being heard through the world at the moment, we may well find ourselves back in the worst of times again for employment.

Source beautifier for SQL statements

2008-08-13T18:31:00.001-07:00

A lot of developers uses source code beautifier tools for their source code, e.g. our ObjectPascal. But I found a nice online-tool for SQL-statements. You can not only format the SQL-command for the Database-server (Oracle, MSSQL and other) like the following result:
SELECT HHJ,
CUSTOMER,
ORDER_ID
FROM TABLE

On the right side you have some options for formatting.

You can format this SQL-Statement for Delphi .....

var1 := 'SELECT HHJ,' ;
var1 := var1 + ' CUSTOMER,' ;
var1 := var1 + ' ORDER_ID' ;
var1 := var1 + ' FROM TABLE' ;

And other languages... e.g. for C# you can choose between
String var1 = "SELECT HHJ," ;
var1 = var1 + " CUSTOMER," ;
var1 = var1 + " ORDER_ID" ;
var1 = var1 + " FROM TABLE" ;
and
StringBuilder var1 = new StringBuilder("SELECT HHJ,");
var1.Append(" CUSTOMER,");
var1.Append(" ORDER_ID");
var1.Append(" FROM TABLE");

I found this very usefull for formatting my SQL-statement to read it sometimes later better..

Here you'll find the Online SQL and PL/SQL Formatter

CreateInstall Free 4.14.3

2008-08-12T14:53:00.005-07:00

O CreateInstall Free é uma ferramenta poderosa para a criação de instaladores para suas aplicações. Permite um controle completo de todo o processo de instalação de uma aplicação, desde o processo de preparação dos diretórios, até no momento de registros de sua aplicação juntamente com o sistema operacional utilizado.Algumas funcionalidades desse software:Todas as operações podem ser modificadas utilizando a linguagem Gentee, tornando as possibilidades ilimitadasControle total durante os processos de instalação e desinstalaçãoPossibilidade de modificar o visual das caixas de diálogoUtiliza um método de compressão altamente avançado, tornando sua aplicação extremamente portável, o que facilita a sua distribuiçãoPossibilidade de exportar os projetos criados para o CreateInstall e realizar as modificações que necessitarInformações adicionais:Ao clicar no botão "Faça o download", você poderá também baixar um pacote de linguagens e poderá modificar o idioma desse software para o Português - BRO CreateInstall Free é a versão freeware do CreateInstall
Roda em Windows 95, 98, NT, 2000, Millenium, XP, 2003
Baixar: http://www.superdownloads.com.br/download/159/createinstall-free-gentee-inc/

When being "objective" is being "biased"

2008-08-12T14:53:00.004-07:00

I did the most unconscionable thing a few weeks ago. Something I've resisted for a very long time. I bought a Mac. For the first time. Ever. I'm not against Macs or Apple in general (I own an iPod and a Zune), in fact I find them very quaint and ...

Rave BE and Windows Vista

2008-08-12T14:53:00.003-07:00

I received last week an email about problems with Rave BE and Windows Vista. I installed a version of Vista in VMWare and then Delphi with Rave BE.

Rave Version 8 (it should be available in the next few days!) works with Vista, of course.
Rave BE and BEX < 8 works with Vista, too

If you have problems try the following:

Rave BE is installed in the same directory structure as the version of Delphi was. In general, this will be the "c:\Programme" here in Germany or "c:\Program Files" in english. To attempt to resolve the Windows Vista security restrictions, you need to make sure that your "Group" or "User Name" has the "Full Control" permissions set to "Allow".

Go to Program Files directory where you install the CodeGear / Borland product Program File\CodeGear\RAD Studio\5.0
Highlight RaveReports
Right Click on RaveReports and Open properties
Click the Security Tab
Select your own user name from the list displayed
Click the Edit button
Select your own uses name again
Go to the "Permissions for Users" dialogue box
Click the 'Full Control' Allow box
Click Apply
accept all the prompts

In my next post I'll explain the steps for Rave Reports BEX (Borland Edition eXtended) versions 7 or earlier.

India again

2008-08-12T14:53:00.001-07:00

Last time I went to India I had a great time, I promised pictures I know, I managed to lose most of them when I recently had to rebuild my machine, but good news, I am coming to India again soon, and I will definitely post them up this time (yeah ...

German ECO book gets an update!

2008-08-11T19:03:00.008-07:00

Wow! Great work, Alois! The German ECO III book got lots and lots of new content. And even better: Alois announced in the newsgroups that an English version is in the works.

And the best thing about it: it is all available for download for free right here.

Finally! Another Delphi book!

2008-08-11T19:03:00.007-07:00

The title ".NET 2.0 for Delphi Programmers" might sound misleading at first, but as I have seen the table of contents, which can be looked at here, I immediatelly pre-ordered it. It is already available in the United States at Amazon.com, but not yet in Germany.

The book is written for Delphi developers who want to get to know .NET. I was pretty overwhelmed when I looked at Delphi for .NET without actually knowing anything about .NET. At that time, there was only a book that dealt with C# to show what .NET was all about. However, right now I would have the choice to order a book that used Delphi instead of another language.

So, count yourselves lucky and be happy that you can order a Delphi book that can get you started with .NET and gives you a whole lot of the details you need. I prepared two links: United States and Germany.

Thanks Jon!

Note: venkatesh pointed out that he found an eBook-version that is available for 30$. I just wanted to point it out, but have not googled for it yet.

A Unicode teaser

2008-08-11T19:03:00.005-07:00

Here's a small teaser to show you what I've been working on recently:



function EncodeUTF16LEChar(aCodePoint: UCodePoint; aChar: PUTF16Char): Integer;
var
  X, W: Word;
  U: LongWord;
begin
  case aCodePoint of
    { Double-byte char }
    $0000..$D7FF,
    { NOTE: This gap here represents reserved code points, i.e. 'surrogates'! }
    $E000..$FFFF:
      begin
        Result := 1;

        PWordArray(aChar)^[0] := Word(aCodePoint);
      end;
    { Quadruple-byte char - surrogate pair }
    $010000..$10FFFF:
      begin
        Result := 2;

        X := Word(aCodePoint);

        { High surrogate }
        U := (aCodePoint shr 16) and ((1 shl 5) - 1);
        W := U - 1;
        PWordArray(aChar)^[0] := Word($D800 or (Word(W) shl 6) or (X shr 10));

        { Low surrogate }
        PWordArray(aChar)^[1] := Word($DC00 or (X and ((1 shl 10) - 1)));
      end
  else
    raise Exception.CreateResFmt(@cInvalidCodePoint, [IntToHex(aCodePoint, 8)]);
  end;
end;

I'm not revealing any details for now, so I guess you'll just have to check back. :)

I was pickpocketed today...

2008-08-11T19:03:00.003-07:00

Yeah. I've involuntarily joined the masses. I guess it was bound to happen, but until now I've foolishly believed I was living in a country where this kind of crime was more of an exception than a rule. Well, that should teach me...

I was in a completely empty waiting room at a dentist's office, waiting for my wife to come out (my brave girl had her wisdom tooth extracted today, ouch) and for a minute I turned my back on our coats that were hanging just a few steps from me. I guess that was one minute to long. I only noticed my wallet was missing 20 minutes later, when we were leaving the building...

In the end, I consider myself lucky - the wallet was practically empty! They only got about €2 (that's roughly $2.5), my driving licence, the key to my office and some other unimportant knick-knacks. I've recently been reorganizing my wallet and I moved all my credit cards and personal documents out of there and have been keeping it in a separate pocket, which thankfully snuck under the thief's radar.

The funny thing is, I almost wish they had stolen my credit cards instead of the driving license! All my credit cards and the money on them are insured for theft so I wouldn't actually lose a cent. The driving license, however, had my photo inside. This means, I'm going to have to go and have another one taken, which I kind of hate doing...

I still hope the thief shows some honesty and takes the €2, buys an envelope and a stamp and returns my driving license to me. Yeah, what can I say... I'm an optimist.

[EDIT 17:30]

It seems this is my lucky day! The police notified me that someone has found my driving license not 200 meters from the scene of crime, just around the corner of the building my wife and I were in. It was accompanied by almost everything else I was keeping in my wallet - except for the €2, the office key and the wallet itself. They said it was probably work of one of the drug addicts that scour the waiting rooms in that area.

Apparently, he'll be able to acquire a week's worth of syringes with the wealth he got from me. My only response to this is: "Go for it, pal!"

Still looking at the map.

2008-08-11T19:03:00.001-07:00

On my last post about the Delphi road map I got very interesting comments. Those comments made me think about what is really needed to take Delphi back to the place it deserves as a development tool.

In my opinion CodeGear needs to focus on the Tool instead of the language. Improvements such as Unicode support, 64 bit support, cross platform support (Windows, OS X, Linux, Symbian, etc.), IDE stability, productivity features, new databases support and more.

I agree with those who think that Codegear should stop playing the “me too game” and stop pursuing the .Net stuff. I’ll take native development over .Net any day.

Adding features to the language can be beneficial. But, at this point in time, I think it is secondary. I still can accomplish all that I need with the current language.

I invite you to post your comments and/or take the poll on the right.

Thank you for stopping by and happy coding!

Keyword

Delphi

The secret of xs:dateTime

2008-08-10T14:24:00.005-07:00

One man's dream tool can very well be another's cause of nightmares. The difference is in knowing the right secrets of using the tool...

Today, I'm going to let you in on one about the xs:dateTime.

OK, I'll admit - I'm being overly dramatic. It's not really a secret, however it is something that's quite easy to miss.

But first, what is xs:dateTime?

In short, it's a standardized way of representing a date/time value in form of a string. It's covered in detail by the current version of W3C Schema, Part 2: DataTypes. It is deeply connected to ISO 8601 and is in fact a subset of that standard.

I'm not going to bore you with dull definitions, because you can learn everything and more than I could ever tell you by simply following the above links.

Instead, let's take a look at a sample date/time value in xs:dateTime format:

2007-02-17T14:40:32.000Z

Even without any specific knowledge of the xs:dateTime, you can tell the year, month, day, hour, minute and second, yes? If not, than go and follow the above links.

If you're still here, this means you're probably also able to deduce where the milliseconds are hiding. And you may or may not know what that 'Z' at the end stands for. Anyway, that's what I want to talk about in this article, so keep on reading...

The 'Z' stands for the time zone zero, or 'Zulu', which is a military way of pronouncing the letter 'Z'. In other words, it tells us that the date/time value is specified in UTC (Coordinated Universal Time). Simply put, UTC is a common denominator for all the date/time values that different parts of the world use to represent their local dates/times. Any local date/time value can be expressed as a relative difference towards UTC, which itself is constant no matter where on this planet (or even above it) you are.

Here's another example of a xs:dateTime formatted value, this time using the relative difference to UTC approach:

2007-02-17T15:40:32.000+01:00

Guess what? It's the same date/time value as before! The '+01:00' part tells us that it's a local date/time value with one additional hour compared to UTC. This is the formula:

[Local date/time] = UTC +/- [xx:xx]

And this is the same formula using the values from the above case:

2007-02-17T15:40:32.000+01:00 = 2007-02-17T14:40:32.000Z + 01:00

Incidentally, this date/time value belongs to my local time zone - the Central European Time Zone on Winter Time, to be precise. In summer, the relative difference to UTC changes to '+02:00', because our local clocks are moved one hour ahead to compensate for the daylight saving. I won't be going into that here, because that would be well beyond the scope of what I wanted to cover.

As such, UTC is obviously the most appropriate base for date/time comparison - a very common operation in software.

But is it equally appropriate for display in user interfaces? It turns out this is not as simple as it seems...

Most human beings on this planet are highly attuned to the natural definition of day and night, which directly corresponds to the relative position of the Sun against our location. That's where everyday phrases like "in the morning", "in the evening", "at noon", "at midnight", etc. come from in the first place. We naturally expect* that 08:00 happens sometime in the morning, wherever we might be at that time.

* - I'm talking in 24 hour clock format here, of course. I'm not getting into any of that 12 hour format nonsense...

The problem with this is, that 08:00 in Slovenia isn't quite the same as 08:00 in, say, Washington DC, even if the date part is exactly the same. They're both "in the morning", but the morning in question comes 6 hours earlier for Slovenia than Washington DC!

Imagine you were writing a software for listing global events. Let's examine the different ways of storing the dates/times of each event entry...

Say the dates/times of all entries were local to respective event locations... You'd probably have a hard time sorting out, which event came before which without looking up the time zone info for every single event. Sure, you may have all that info, but it'd still require work!

How would this look like, if all entries used UTC instead? Sorting would be a no-brainer - just compare the values directly, and voila! But then your users would lose the ability to tell at a glance, in which part of the day a particular event actually happened. They don't want to think about time zone differences to figure out what 03:45 UTC means, remember?

So what's left, then? Well, you could keep all entries using local dates/times, but add the relative difference to UTC for each entry. Sorting would still be easy, it'd just require some simple math to add or subtract the relative difference from the base value. And the users would still be able to get the local values they expect.

OK, so that's nice... But what if only some of the users wanted to see the values in the event-local date/time, while others wanted to see them as UTC or even in their local date/time? This could very realistically be the case in an online meeting scheduling software - an advanced IM, if you like. Would local date/time with relative difference to UTC be able to cover all possibilities?

Well, with a little help from client OS, it would and it is... :)

Given the event-local date/time and its relative difference to UTC, client software can easily calculate all three values:

the event-local date/time directly from input value,
the plain UTC by adding or subtracting the relative difference from base value, and
the user-local date/time, provided the local time zone info from the OS.

Although the latter could be done just the same with only the UTC value in the first place, it would be much harder to retrieve the event-local date/time, since there is no info on the event's time zone in plain UTC.

Ah, excellent! It appears we've truly found a winning combo!

By storing the date/time values in xs:dateTime format and including the relative difference to UTC, we've both retained the information about the event-local date/time and included the implicit UTC value for use in further conversions. All thanks to the expressing power of xs:dateTime!

So next time you find yourself deciding on the appropriate storage format for date/time values, think about using the yyyy-mm-ddThh:mm:ss.zzz[+/-]xx:xx variant of xs:dateTime, especially if dealing with XML! It gives you everything a plain UTC variant would, with bonus of preserving the local date/time for when it matters.

Detecting various Windows versions

2008-08-10T14:24:00.003-07:00

Sometimes you need to know the version of Windows you're running on. Here's a simple unit I've whipped up for myself, that anyone can use.

I can't guarantee the code actually works as advertised, but it should be able to recognize the following versions of Windows:

Windows 95
Windows 95 OSR 2
Windows 98
Windows 98 Second Edition
Windows Millenium
Windows NT 3.5
Windows NT 4.0
Windows 2000
Windows XP
Windows XP Service Pack 2
Windows XP x64
Windows Server 2003
Windows Vista
Windows Server Longhorn

No special license applies, so just enjoy! You're welcome to report if you find any problems with the code...

Overloading array properties in Delphi/Win32

2008-08-10T14:24:00.001-07:00

A few days ago, a colleague of mine, Lee_Nover, approached me with an interesting problem. He was looking for a way to overload an array property of an object, so that items could be accessed by differently typed indexers.

Basically, he wanted to do this:



O := MyObj.Items[0];
O := MyObj.Items['ObjName'];
O := MyObj.Items[Now];

The point of this exercise was to accomplish this in Delphi/Win32. C#/.NET has this, but that's only because properties are implemented differently there than they are in Delphi/Win32.

By the time he got to ask for my help, my colleague had already discovered several ways to do this:



property Items[const aIndex]: TObject ... ;
property Items[aIndex: array of const]: TObject ... ;
property Items[const aIndex: Variant]: TObject ... ;

All of the above did the job, but none were too elegant. Untyped indexer was great for accepting different types, but offered no elegant way of retrieving the actual type that was being passed into the argument. Array of const indexer somewhat solved this problem, but imposed an additional set of square brackets when accessing the property. Variant indexer was the most promising, but it still offered no way of limiting the accepted indexer types at compile time.

After a little bit of thinking, I suggested a different solution: using a record type indexer with overloaded operators -- a feature introduced in Delphi 2006/Win32.

Surely enough, we tried it, and it worked! Here's an example of what we did:



type
  TDataType = (dtInteger, dtString);

  TIndex = record
    DataType: TDataType;

    IntValue: Integer;
    StringValue: AnsiString;

    class operator Implicit(aValue: Integer): TIndex;
    class operator Implicit(const aValue: AnsiString): TIndex;
  end;

  TNamedObjectList = class(TObject)
  ...
  public
    ...
    property Items[const aIndex: TIndex]: TObject read GetItem write SetItem; default;
  end;

And here's the implementation of the record's operators:



class operator TIndex.Implicit(aValue: Integer): TIndex;
begin
  Result.DataType := dtInteger;
  Result.IntValue := aValue;
end;

class operator TIndex.Implicit(const aValue: AnsiString): TIndex;
begin
  Result.DataType := dtString;
  Result.StringValue := aValue;
end;

This way, the property can be accessed by both Integer and AnsiString indexers. Thanks to overloaded operators, compiler takes care of translating both simple types into a record type -- this is sort of similar to the .NET concept of "boxing".

Accessor methods of the property can then determine the actual value along with its type directly from the record's fields:



function TNamedObjectList.GetItem(const aIndex: TIndex): TObject;
begin
  case aIndex.DataType of
    dtInteger: Result := fList.Objects[aIndex.IntValue];
    dtString:  Result := fList.Objects[fList.IndexOf(aIndex.StringValue)];
  else
    Result := nil;
  end;
end;

procedure TNamedObjectList.SetItem(const aIndex: TIndex; aValue: TObject);
var
  Idx: Integer;
  ...
begin
  case aIndex.DataType of
    dtInteger: Idx := aIndex.IntValue;
    dtString:  Idx := fList.IndexOf(aIndex.StringValue);
  else
    Idx := -1;
  end;
  ...
  fList.Objects[Idx] := aValue;
end;

This approach has the extra benefit of using compile-time type checking. The way we overloaded the Implicit operator, we limited the accepted indexer types to Integer and AnsiString. Nothing else will be accepted by the compiler. Any other type can be added later by simply adding more overloads to the Implicit operator.

Here's a sample project which demonstrates the usefulness of this approach.

Obviously, this solution works just as great for interface properties as it does for object properties. The only down side is that it requires a Delphi 2006 compiler or newer. But then again, who's still using anything below that -- especially now, when an enhanced version (i.e. Delphi 2007) is just around the corner? ;)

[EDIT 2007-03-15T17:45]

There are times when reading the help can actually save you some work... Commenter Steve found a much simpler way, that can be used when you only need one overloaded property for a given class. Simply declare that property multiple times with different indexers, and mark all copies with default directive. Please refer to article's comments for more details.

Chat em Delphi

2008-08-09T20:16:00.001-07:00

Certa vez tentei fazer um chat aonde o usuário movimentasse um personagem pela tela. Essa idéia era baseado no Habbo Hotel. Conheci esse serviço nesse tópico na CdMJ.

Primeira coisa que fiz foi arrumar um chat pronto em Dephi com o código fonte disponível. Dentre os que achei, decidi utilizar o CHAT WOTT que se divide em Cliente e Servidor.

Tela do Cliente

Tela do Servidor

Depois procurei aprender a movimentar um personagem pela tela. Achei um MMORPG utilizando os componentes do DelphiX. Perguei o código responsável pelo movimento e incluir no cliente do chat.

Tela do Cliente Modificado

Cheguei a fazer alguns testes com o chat que eu modifiquei. Criei um redirecionado no no-ip.com, e rodei o servidor no meu computador. A parte do chat funcionou bem. Só não terminei a parte do personagem. A intenção era que aparecesse um balão no personagem com o que o seu usuário digitou.

Links sobre o assunto na CdMJ

Quem sabe um dia eu termine esse programa.

Vou procurar o endereço do MMORPG em delphi que eu achei.

Compare Preços: Informática, Assinaturas e Revistas, Livros, E-Books, HandHeld/Palm Top, Notebook, Revistas CD-ROM, WII, Xbox 360, Zire 22

Technorati Tags: chat, delphi, mmorpg, delphix, avatar

----
Data Original: 2007-05-01 8:58:39 pm

Pascal para iniciantes, o vídeo

2008-08-09T11:29:00.001-07:00

HI,

Acabei de assistir esse vídeo e tou com dificuldade até agora para respirar. É muito hilário, hehehe.

Vejam o quanto é complicado determinar se um número é primo ou não.

Até a próxima.

Vídeos sobre desenvolvmento de sistemas

2008-08-09T09:04:00.001-07:00

HI,

Vou colocar aqui os links de alguns vídeos que achei sobre programação.

Delphi 7 - Dicas (Parte 1)

Delphi 7 - Dicas (Parte 2)

ASP.Net Web Service - Hello World (With Audio)

The Basics Of Java Programming

Eclipse and Java for Total Beginners

Tutorial "creating web services" with NetBeans

Uploading YouTube Videos with the PHP Client Library

PHP file upload

DataSets and StoredProcedures in Visual Studio 2008

Migrando para .NET Framework - Visual Studio 2008

Qualidade em projetos de software

Espero que aproveitem os vídeos.

Até a próxima.

Listando informações dos Aliases

2007-12-24T09:56:00.000-08:00

Com o código abaixo você poderá desenvolver um pequeno aplicativo para obter informações dos aliases contidos em sua máquina. Inicie uma nova aplicação. Insira no formulário, 4 componentes do tipo TLabel e um TListBox. No evento OnCreate do objeto Form1 digite o seguinte código:

procedure TForm1.FormCreate(Sender: TObject);
begin
Session.GetAliasNames(ListBox1.Items);
end;
Agora no evento OnClick do componente ListBox insira:
procedure TForm1.ListBox1Click(Sender: TObject);
var
tStr: array[0..100] of char;
Desc: DBDesc;
begin
if ListBox1.Items.Count = 0 then
exit;
StrPLCopy(tStr, ListBox1.Items.Strings[ListBox1.ItemIndex], High(tStr));
DbiGetDatabaseDesc(tStr, @Desc);
with Desc do
begin
Label1.Caption := StrPas(Desc.szName);
Label2.Caption := StrPas(Desc.szPhyName);
Label3.Caption := StrPas(Desc.szDbType);
Label4.Caption := StrPas(Desc.szText);
end;
end;

Tools for the Development Team (2)

2007-10-15T13:20:00.000-07:00

To continue where I left off, the management team, of which I am a member, looked at Jira in a totally different manner. Each person had their own needs for a tool ever so slightly different to Jira. This caused some problems as I was then asked to evaluate a number of other tools that, perhaps with some compromise, everyone can use. Some suggestions were forthcoming and I dutifully took at look at each one.

The problem with the approach that I made to the management team was that I had obviously failed to impress what the development team needed in the tool. You see, I was out to sell the tool to the rest of the company and in doing so I was focusing on their needs instead of the development team's. This meant that instead of learning how the development team were going to contribute and communicate better, they were thinking "how can I use this new tool", which invariably led to "I need this tool to do X, and I know one that does X much better than this". Of course, that meant that they were thinking of their own needs and Jira just didn't cut it for them. Dang, I missed the plot there.

I got suggestions to consider like Phpaga (http://www.phpaga.net). This is an excellent tool for contacts, invoices, financials, and billing tasks, but it has little to nothing to do with the development process. After discussing this and writing up a small review for the management team I suggested that a CRM package was more in line. They have one so will look again at using it effectively.

Almost all applications I looked at served a single particular purpose, and added some other purposes somewhere along the scale of between "ok" and "that really sucks".

So lesson learned. What I should have done is sold it as a development tool. I could have shown the management team how much better the development team was going to be, how much more accountable, how they will now get both statistics and answers from this bunch of strange speaking weirdos that did things magical and totally unknown things that produced the final products. Now they might understand what's going on there and the tool will be well supported.

As I stated in my last email, I have a number of tools that I will touch on briefly over the next few posts, but as you might have guessed, we have finally decided on Jira. Surprisingly that decision was not made by me. The development team were also asked to review a few of the more successful tools and give their feedback but it was their own decision that we should go with Jira. While Jira did not have the nicest interface or the best reports, and it was only an issues register, it was voted in as the tool to use.

Fonte: http://stevepeacocke.blogspot.com

Tools for the Development Team

2007-10-11T14:47:00.000-07:00

We placed Jira onto our live server and began using it for real about 2 weeks ago now. So how's it going? Rather well as it turns out.

(Jira is from Atlassian (http://www.atlassian.com/software/jira/) and is an issue tracker tool, see earlier posts for discussions.)

I did a demo for the Development Team and they took to it like a duck to water, now that they understood what it's used for and how. I did the same for the rest of the Management Team and they took to it as well, but in a different way.

Initially it was not used as well as I'd have liked so I put a little pressure on the team by being a bit of a pain in the neck for a couple of days..

Me: "What are you working on?"

Developer: "I'm updating xyz here that needs a new abc because Freda from WxyCorp has found a glitch with it"

Me: "I don't see this in Jira, have you added it?"

Developer: "Um... (ticidatacida) .. I have now (grin)"

Me: "Oh, OK then. You know that if you are working on anything, no matter what it is, it .."

Developer: ".. yea yea, I know, - ..'it needs to be in Jira' (sigh)"

The developers are good guys and they really understood the reasons for putting everything in Jira but being developers, they wanted to just develop. Now I note that no-one is working on anything without a Jira issue and they themselves police that nicely by suggesting that others create a Jira issue before they can start on any work. Nice.

This means of course, that all work is logged and reporting and reviewing can be carried out. Issues are assigned to others with questions when more information is needed, and they get an email to tell them when the issue is reassigned back to them with the answer. Once the have completed the work, they "Resolve" the issue and assign it to the QA Manager. Only the QA Manager and myself as Administrator, can "Close" an issue.

The Management Team has been impressed with Jira but they all have their own ideas of other tools that would work better for what they want to do. Some other tools that I have looked at are...

SourceForge Enterprise - http://sf.net/powerbar/sfee/
Trac - http://trac.edgewall.org/
Mingle - http://studios.thoughtworks.com/mingle-project-intelligence
Confluence - http://www.atlassian.com/software/confluence/
FDDTracker - http://www.itps.com.au/dotnetnuke/

Other areas I have also look at with a mind to solving some other issues here, they include...

TrueCrypt - http://www.truecrypt.org/
AllSync - http://www.allsync.biz/help/a_produktbeschreibung.htm
SyncToy - http://www.microsoft.com/windowsxp/using/digitalphotography/prophoto/synctoy.mspx

and I'll hope to have others added to that list soon.

I'll talk on each of those and our eventual decisions as I go along in other posts. In the meantime, I'd like to hear what tools you are using with your team or even on your own to help with development and running a software team.

Fonte: http://stevepeacocke.blogspot.com

Firebird System Tables (Part IV)

2007-10-05T01:30:00.000-07:00

The system table for stored procedure is like here. The purpose of this view is the same like in Firebird System Table (Part II).

CREATE VIEW "vSYS_FindProcSource"(
"procName",
"procSource")
AS
select r.rdb$procedure_name, r.rdb$procedure_source
from rdb$procedures r
where r.rdb$system_flag = 0;Fonte: http://firebird-with-delphi.blogspot.com

Firebird 2.0.3 is released

2007-09-29T04:48:00.000-07:00

On 26 September 2007, Firebird version 2.0.3 is released, you can download in here. This version is only bug fixed version from FB 2.0Fonte: http://firebird-with-delphi.blogspot.com

Installing Jira - The Development Support Tool

2007-09-27T20:57:00.000-07:00

We are a relatively small (less than 20 employees) software development house with about half a dozen mainline products as well as any number of consulting projects going on. We have some very big name clients in several countries and therefore need to ensure work is completed on time and efficiently.

While there are normal enhancement projects and major installation projects going on, there are also a number of items that come up for customers wanting changes or where something doesn't go quite as planned. These can disrupt the programmers day and disturb the development of future enhancements or otherwise frustrate the project timelines.

We have a web based system for clients to record requests and log bugs. This is monitored by our support staff and an email is fired off to developers where necessary.

All this means that as more emails come in, the developer has to judge the urgency of the email and either drop everything to perform that task, or note that this is another item that he has to do in the future. While they are very good at what they do, I was concerned for several reasons.

I don't have a view on what a developer is doing at any time, or what he has done
I don't have any way to tell what the workload of a particular developer is. This means I don't know to spread the load between developers when one is overloaded and another is just doing some normal housework
Programmers can easily forget tasks
It doesn't assist in any process to development
I can't plan to ensure enough resources are available.
I could go on, but you get the idea...

Generally though, it makes the whole development area invisible to me as the manager.

I knew that I needed to install a development process, but I knew immediately, I needed a tool to give me the visibility on what's being worked on work to correctly design a development process. I had used Jira before so the decision was an easy one for me. Setting it up was easy and done in minutes, but I wanted a number of changes to the permission and notification schemes, then it was a matter if creating some projects. Done.

It worked well and I installed a testing project so that people can try out the system without disturbing real work.

Its been installed now for about a week but the uptake has not been immediate. I'll have to do a demo on Monday to show everyone how it works, assure them that its not going to take over their day with mundane admin tasks, and finally show them a few neat wow bits. After that I'll be enforcing the use of it for the next month.

If, after that trial, no-one is convinced, then I'll take it away, but I'll need to know what to replace it with if that is the case. There seems to be a few main problems with installing this work request system that I'll have to overcome. These include:

It seems like more work for no reason. While it may take a minute or less to create a new Jira issue, there are huge benefits for the user, the company, and the client - get over it.
Its a way for the boss to monitor my work so he can breathe down my neck. In fact, its a way to STOP the boss breathing down your neck as he can see what's going on instead of bugging you every half hour. As for monitoring, your not that interesting that I want to spend all my time "monitoring" what you are doing "right now", I'm a lot busier than that but a quick glance to review workloads will tell me if you have too much work and need help.
I get lots of little emails from lots of people wanting me to do things that only take a minute or two, why should I have to put all these into Jira?. By putting these into Jira, these little jobs will not only show you how much time they take up, but you will never, ever forget to do them. I have set up an email for each project in Jira, simply forward to the email to that address and it'll create your Jira issue instantly.
I'm a senior developer, surely "I" don't have to do this. Yes, sadly I'm afraid that you do.

I'm sure that once everyone is using it and the advantages are being seen, then it'll resolve any arguments. To be fair, no argument have been forthcoming, but I can sense what's not being said at times. They are a great bunch or people that I enjoy working with, I just think I can make life easier for them with this tool. I'll let you know how it goes.

Fonte: http://stevepeacocke.blogspot.com

Installing ZeosDBO in Delphi (rev version)

2007-09-26T20:04:00.000-07:00

I already make some revision on my previous post about how to install ZeosDBO components in Delphi. The revision link is here. ZeosDBO is one of the direct connection components to many RDBMS including Firebird. The idea of ZeosDBO is like JDBC, and to switch from one database to another database is really easy, find it by yourself after trying this amazing components. One thing, this component is FREE and OPEN SOURCEFonte: http://firebird-with-delphi.blogspot.com

Firebird System Tables (Part III rev 1)

2007-09-26T19:49:00.000-07:00

Here is some revision (from Romkin idea) to the query of Firebird System Tables part III.
In this query, it doesn't need anymore to has "case" statement to get the convertion from numeric type_name to more readable name. And I want to say thank you for the supporting comment on this little articles. Once correction from Milan Babuskov that told me "CONTAINING" is in Firebird since the first versions 1.0. Hope all articles in this blog can be usefull for FB community. Wait for the next Firebird System Tables again, stay tune on the same channel he..he..he.. :)

CREATE VIEW "vSYS_FindDependencies"(
"dependentName",
"dependentType",
"dependedOnName",
"dependedOnFieldName",
"dependedOnType")
AS
select d.RDB$DEPENDENT_NAME DEPENDENT_NAME,
(select t.RDB$TYPE_NAME from RDB$TYPES t
where d.RDB$DEPENDENT_TYPE=t.RDB$TYPE
and t.RDB$FIELD_NAME = 'RDB$OBJECT_TYPE'
) DEPENDENT_TYPE,
d.RDB$DEPENDED_ON_NAME DEPENDED_ON_NAME, d.RDB$FIELD_NAME DEPENDED_ON_FIELD_NAME,
(select t.RDB$TYPE_NAME from RDB$TYPES t
where d.RDB$DEPENDED_ON_TYPE=t.RDB$TYPE
and t.RDB$FIELD_NAME = 'RDB$OBJECT_TYPE'
) DEPENDED_ON_TYPE
from RDB$DEPENDENCIES dFonte: http://firebird-with-delphi.blogspot.com

Finally closing this blog

2007-09-24T02:01:00.000-07:00

Well, it is about time to close this blog officially, however, not without starting a new blog on my own server. So yes, I will start blogging again and I will write about Programming with Delphi (and C#) as well as other aspects of my life.

The new blog supports categories and is just starting, so you have not missed anything so far ;-)

To read my new blog, go to http://www.gumpi.com/ and start reading.

Thanks to all readers in the past, and hello to all readers to come.

* * * THIS BLOG IS CLOSED NOW * * *

Fonte: http://delphi-notes.blogspot.com

Firebird System Tables (Part III)

2007-09-20T21:12:00.000-07:00

This article idea (Part III) is belong to the someone that put comment on my previous article, so I just accomodate his/her idea. And I already arrange to become a view like this:

CREATE VIEW "vSYS_FindDependencies"(
"dependentName",
"dependentType",
"dependedOnName",
"dependedOnFieldName",
"dependedOnType")
AS
select RDB$DEPENDENT_NAME,
case RDB$DEPENDENT_TYPE
when 0 then 'Table'
when 1 then 'View'
when 2 then 'Trigger'
when 3 then 'Computed field'
when 4 then 'Validation'
when 5 then 'Procedure'
when 6 then 'Expression index'
when 7 then 'Exception'
when 8 then 'User'
when 9 then 'Field'
when 10 then 'Index'
when 14 then 'Generator'
else RDB$DEPENDENT_TYPE
end DEPENDENT_TYPE,
RDB$DEPENDED_ON_NAME, RDB$FIELD_NAME,
case RDB$DEPENDED_ON_TYPE
when 0 then 'Table'
when 1 then 'View'
when 2 then 'Trigger'
when 3 then 'Computed field'
when 4 then 'Validation'
when 5 then 'Procedure'
when 6 then 'Expression index'
when 7 then 'Exception'
when 8 then 'User'
when 9 then 'Field'
when 10 then 'Index'
when 14 then 'Generator'
else RDB$DEPENDED_ON_TYPE
end DEPENDED_ON_TYPE
from RDB$DEPENDENCIES;

The idea is to know the dependency on some entity in the database. Perhaps it is also usefull for everyone.Fonte: http://firebird-with-delphi.blogspot.com

Back again

2007-09-20T14:37:00.000-07:00

Thanks for your patience, I have finally shifted house and started my new role as Software Development Manager for a software house in Hamilton.

The shift included a few days in Wellington visiting friends and generally spending time away. Holidays have been a very rare occurrence for me, having at one time, spent more than 12 years without a holiday, I find that taking a break occasionally is a requirement.

The new role is interesting. Based on Oracle technologies the product is a very stable and sizeable system. The team contains some excellent technical expertise and I will be working hard to install some processes and a decent methodology to ensure that they are supported as much as possible.

That's all for now as I'm still finding my feet here.

Fonte: http://stevepeacocke.blogspot.com

Firebird System Table (Part II)

2007-09-19T20:51:00.000-07:00

Another FB system table is system table for trigger. The reason I create this view is to scan for some code inside the source of the trigger. For example, I want to change the field type of table A, then I want to know, this field is being used by which trigger, so I can search thorough this view:

CREATE VIEW "vSYS_FindTriggerSource"(
"triggerName",
"tableName",
"triggerInactive",
"triggerSource")
AS
select r.rdb$trigger_name, r.rdb$relation_name, r.rdb$trigger_inactive, r.rdb$trigger_source
from rdb$triggers r
where r.rdb$system_flag = 0

If you want to seach some text in the trigger source then you can use this simple query:

select *
from "vSYS_FindTriggerSource"
where "triggerSource" containing 'some_field'

The keyword "containing" here (if I'm not forget) is exists from FB 2. The difference between "containing" and "like" is the "like" is case sensitive where "containing" is case insensitive, and also you not need the "%" sign like in "like" keyword.

That view also display the status of the trigger, if the "triggerInactive" field value is zero, then it means that trigger is active and vice versa.Fonte: http://firebird-with-delphi.blogspot.com

Firebird System Tables (Part I)

2007-09-17T23:06:00.000-07:00

Hi, whew it's has been long time since my last time post, yes I a little bit busy now, with some of my own project and some of my family work. Ok, now I want to share about Firebird System Tables, they are tables that side on every FB database that consist of metadata of user tables (table that you created), many question about this and also many purpose to know about this.

I often use this technique when I develop a database that consist of many tables and where there is an error on one of the field and then I must know this field is belong on which table, to solve that problem, I create a view like this:


CREATE VIEW "vSYS_FindField"(
"tableName",
"fieldName",
"default_val")
AS
select r.rdb$relation_name, f.rdb$field_name, f.rdb$default_source
from RDB$RELATIONS r, RDB$RELATION_FIELDS f
where r.rdb$system_flag = 0
   and r.rdb$relation_name=f.rdb$relation_name;

The FB System Tables can be known from "RDB$RELATIONS.RDB$SYSTEM_FLAG" greater than 0 (zero). The "RDB$RELATIONS" is a system table for user table and user view (off course it also contain of many things that you can look by yourself ;P) And "RDB$RELATION_FIELDS" is as you may guess is a system table for user field. It's now up to you to improve that query, maybe you want to include some more information, then go ahead :)

NB: Thank's Romkin for the correction, now I already applied your correction in this short article :)Fonte: http://firebird-with-delphi.blogspot.com

Returning the outer directory

2007-09-09T13:47:00.000-07:00

Returning the directory before the current one should be a simple one-line call but I have so often seen a number of very highly convoluted ways of finding the last slash (\) in the directory string and using copy() and other ways that I have decided to relate a simple and direct way to obtain any or all directories prior to, and including the current one.

The problem with finding the last slash is that you have to watch out for cases where the current directory is a root directory. The good news is that you can ignore all of that.

You should know that finding the currently running exe program name including directories is Application.ExeName found in SysUtils. This should return something like..

C:\Program Files\CodeGear\Delphi\5.0\bin\MyProgram.exe

Of course the directory structure may be different as I'm sure you're not running your programs in the Delphi \bin directory :o)

But to get the directory that MyProgram.exe is running in, the call is ExtractFileDir(Application.ExeName). This returns..

C:\Program Files\CodeGear\Delphi\5.0\bin

ExtractFilePath() dies something similar. It simply returns the string up to the last delimiter (the slash). In other words, anything past the last delimiter is ignored as it is assumed to be the program name. Excellent, this means that we can use that fact on the above directory structure to return the previous directory.

PreviousDir := ExtractFilePath(ExtractFileDir(Application.ExeName));

This should return a directory structure of
C:\Program Files\CodeGear\Delphi\5.0\

We can continue to use ExtractFileDir() to return each directory in the tree until we reach the root directory (perhaps checking if PreviousDir = LastDir?). For example:

Dir := ExtractFilePath(ExtractFileDir(ExtractFileDir(Application.ExeName)));

Should return one directory up from the previous dir, or in this case:
C:\Program Files\CodeGear\Delphi\

So there you have it. A single call that returns the previous directory without having to bother with searching for the slash or worrying about the root directory issue.Fonte: http://stevepeacocke.blogspot.com

Accessing Interbase/Firebird Metadata in Delphi

2007-09-06T04:43:00.000-07:00

WARNING: Interbase and Firebird system tables are not for the faint hearted. It is not recommended that you alter anything in these tables if you ever want to use them again - and keep your job. Major stuff-ups can occur.

I was looking at some old Delphi 7 code of mine when I was attempting to get in behind the scenes of Interbase and Firebird tables and fields to learn a little more about them. I came across these little pieces of information I'd like to share.

The following will list all the tables in one grid and, for each table, list all the fields in another grid. Drop on your TIBDatabase and direct it at your Interbase or Firebird server.

Now drop a TIBTransaction, TIBQuery, TDataSource, and a TDBGrid and connect them all.

Enter the following query into the IBQuery1...

  SELECT DISTINCT RDB$RELATION_NAME as MyTable
  FROM RDB$RELATION_FIELDS
  WHERE RDB$SYSTEM_FLAG=0 
  AND RDB$VIEW_CONTEXT IS NULL
  ORDER BY RDB$RELATION_NAME

and make IBQuery1 live. Now drop on another TDBGrid, TIBQuery and TDataSource and connect them. This time, select IBQuery2 and add TDataSource1 in the "DataSource" Property. This will ensure that the second query will look to the first query to fill in the parameters. That parameter will be the field MyTable.

Enter the following query string into the SQL property of IBQuery2...

  SELECT RDB$FIELD_NAME AS FIELDS
  FROM RDB$RELATION_FIELDS
  WHERE RDB$RELATION_NAME = :MyTable
  ORDER BY RDB$FIELD_POSITION

and make that query live. When you run that program, selecting tables in the first grid will show all the field information for that table in the second grid.

So far I have the following types in the field RDB$FIELD_TYPE. These can translate to...

8 = Integer
10 = Float
12 = Date
13 = Time
14 = Char
35 = TimeStamp
37 = VarChar
261 = Blob

There'll be a definitive list somewhere but that's all I have needed so far. I got that list from the internet somewhere but it was so long ago that I have forgotten where (thanks to whoever that was).

That will get you started, but here are some other queries that will return more metadata information...

Return indexes for a table

  SELECT RDB$INDEX_NAME 
  FROM RDB$INDICES 
  WHERE RDB$RELATION_NAME = :MyTable
  AND RDB$UNIQUE_FLAG IS NULL 
  AND RDB$FOREIGN_KEY IS NULL

Return all Generators

  SELECT RDB$GENERATOR_NAME 
  FROM RDB$GENERATORS 
  WHERE RDB$SYSTEM_FLAG IS NULL

Return all Triggers

  SELECT * FROM 
  RDB$TRIGGERS 
  WHERE RDB$SYSTEM_FLAG IS NULL

The shifters are coming in the morning so I'll post this now, please excuse any typing errors. Enjoy your day.

Remember: A positive attitude may not solve all your problems, but it will annoy enough people to make it worth the effort. Herm Albright (1876 - 1944)Fonte: http://stevepeacocke.blogspot.com

Scrolling to the right place in TMemo

2007-09-04T13:12:00.000-07:00

After programmatically inserting a number of lines I find that the TMemo will show at the last line as it normally should. However, sometimes what I really want is for TMemo to move to the first line, or perhaps even move to the top of the last lot of inserted lines.

Here are a few little gems I have picked up on my travels that work a treat.

Move to a particular line in a Memo...

function MemoMoveToLine(LineNo: integer);
begin
    with Memo1 do
    begin
        SelStart := Perform(EM_LINEINDEX, LineNo, 0);
        Perform(EM_SCROLLCARET, LinePos, 0);
    end;
end;

What this is doing is calling TControl.Perform. This function actually uses a Windows message to perform some task, in this case placing the cursor at a line number, and then scrolling to that line. Let's take a look at using that function...

var
    CurrentLine: integer;
begin
    // Get the current position
    with Memo1 do
        CurrentLine := Perform(EM_LINEFROMCHAR, SelStart, 0);    
    AddLotsOfLines;
    // Move to the line we started at
    MemoMoveToLine(CurrentLine);
    // Now Move to the end
    MemoMoveToLine(Memo1.Lines.Count);
    // Now Move to the start
    MemoMoveToLine(0);
end;

And there you have it.

Ramblings

I'm well into packing in the evenings now and surrounded by boxes. The truck comes in 2 days to take my furniture to Hamilton where I will start work as Software Development Manager about mid month. I look forward to the challange of a new team and new company.

Although it will be hard to leave the Mount and this wonderful job and environment, my family is still at the Mount so I'll be back often. Its only a short drive to get here to see them and I'll probably end up with a caravan here for easy weekend stays.

I'll still be codeing in Delphi for my own programs (and sanity), always have, always will. This will ensure that the blog stays relative to Delphi, although I might introduce a few new subjects as well.Fonte: http://stevepeacocke.blogspot.com

What's this Soundex in Delphi?

2007-08-30T13:00:00.000-07:00

Delphi has a Soundex routine found in StrUtils, so why am I giving you another? This blog is about how Soundex works. understanding Soundex will help you decide how and when to use it to enhance your program. I am not suggesting for a moment that you dump the already written Soundex routine within Delphi, unless you really want to, but rather I am suggesting that this may be a way to understand how a Soundex code is put together.

In the early 1980's I wrote a Soundex routine in Turbo Pascal and released it to the world through the bulletin boards that were available back then (before the Internet became readily available to the masses). By releasing it to the public domain, I was more interested in sharing than in copyrighting everything.

Over the following years, to my great amusement, I found my routine copied several times, sometimes word for word, line for line including comments, with my name replaced with someone else claiming to be the author (I would not be so amused these days). As far as I could tell with the limited searching available at the time, I was the first person to write a Soundex routine entirely in Turbo Pascal, but it is a simple routine so I could easily be wrong on that count.

The original Turbo Pascal source has been lost to .. well .. somewhere in that box of 5.5" floppies over in the corner there that I've been taking to the dump any day now for about the last 15 years.

Soundex converts a name to four characters (one letter and three numbers). The conversion will result in the same numbers for like-sounding names. For example all the following names will all result in a Soundex code of "S530" - smith, Smith, smythe, smitt, shmidt, shmidt, snith, snyth, snythe, smmith, etc. This means that if a user enters "Smith", and I search the database for the Soundex code rather than the name "Smith", I will be presented with all those and other similar sounding names.

Soundex was originally invented by Robert C. Russel and Margaret K. Odell around 1918-1922 and initially used for immigration and census information. Being before computers, the Soundex code is naturally simple so that people can calculate Soundex manually. It is used most in computer applications now. Searching your own database for names that sound like 'Smith', for spell checking and other areas.

While Soundex is clever, it is not infallible so common sense must prevail. 'Clark', and 'Klark' will come out with a different Soundex code. other examples are Bate (B300), will not be the same as Bates (B320), or Gate (G300).

In other instances names that really don't sound the same can sometimes, by sheer coincidence, have the same soundex code. Have you ever wondered why sometimes your spell checker wants to replace a mistyped word with something completely different and totally out of context? You are left wondering how on earth the spell checker came up with that word. Well, now you know. Its Soundex. However, it is still clever enough for most uses.

So what's the process? Well, it was simple for a reason (above) and still is.

Take the first letter
Replace the letters BFPV with '1'
Replace the letters CGJKQSXZ with '2'
Replace the letters DT with '3'
Replace the letter L with '4'
Replace the letters MN with '5'
Replace the letter R with '6'
Ignore all other letters and ignore double letters (e.g. the 2 T's in "Letterman").
If the result is less than 4 characters, then pad out with zeros.
If result is greater than 4 characters then use only the first 4

And there you have your Soundex code.

There are many ways to implement Soundex and I have chosen one that I hope will allow you to follow what is happening. Take a look at the Soundex routine in StrUtils for another way.

function MySoundex(sName: string): string;
var
    Ch, LastCh: Char;
    i               : integer;
    sx              : string;
begin
    sName := UpperCase(trim(sName));
    if length(sName) < 1 then
        sx := '' // got nothing, send nothing back
    else
    begin
        LastCh := #0;
        for i := 1 to length(sName) do
        begin // step through each character in the name
            if i = 1 then
                sx := sName[1] // store the first character
            else
            begin
                ch := #0;
                if sName[i] <> LastCh then
                begin
                    case sName[i] of
                        'B', 'F', 'P', 'V': ch := '1';
                        'C', 'G', 'J', 'K',
                            'Q', 'S', 'X', 'Z': ch := '2';
                        'D', 'T': ch := '3';
                        'L': ch := '4';
                        'M', 'N': ch := '5';
                        'R': ch := '6';
                        // Note no ELSE - ignore all other letters
                    end;
                    if ch <> #0 then
                        sx := sx + ch;
                    if length(sx) > 3 then
                        break; // we got all we need
                end;
            end;
            LastCh := sname[i];
        end;
        while length(sx) < 4 do
            sx := sx + '0'; // pad out remaining with zero
    end;
    result := sx;
end;

There are lots of variations and improvements on that depending on what you are doing.

So where would we use Soundex? One obvious way would be to give your users the ability to search for a name by the way it sounds.

Consider a database full of hundreds of thousands of customers. Simply add a field to the Customer table called .. oh I don't know, how about "Soundex". Then add the soundex code for the customer surname on each customer.

Because of the way Soundex works, you may find that finding all customers that sound like "Smith" may be a lot faster than finding all customers with the exact name of "Smith". How can this be? Well, since there will be less unique Soundex codes than unique surnames, the index will have less problems finding a Soundex code. Lets say that you are searching for a name in Auckland (approx 1.3 mill), an index on unique surnames will possibly total around 800,000 (rough guess). However an index on unique Soundex codes for surnames may only total about 100,000 (another wild guess with no substance at all, but you get the idea).

Ramblings

Its beautiful outside again today and although yesterday the wind was getting up a little, I can start to feel the rumblings of spring around here. Are we at last getting out of the deep dark winter that held our grip for the past few months and kept us close to our box of tissues, warm jerseys, and heaters? I hope so. It made me think of where I would be if I had accepted the offer to spend the next few years in Mongolia. I would have loved the experience of learning a new culture and language, but "The Mount" has a way of making me smile.

I climbed to the top of the mount again last weekend where the view is spectacular.
Mount Maunganui from the top of the Mount. It was sad to think I'll soon be moving inland to Hamilton, an hour and a half away.

Have a wonderful day wherever you are and God's blessings.Fonte: http://stevepeacocke.blogspot.com

Have an iif() function in Delphi

2007-08-22T16:32:00.000-07:00

There are many advantages to learning other programming languages, but there are also some problems as well. The "Immediate If" (iif) function is one of those. In most, if not all, the other languages there is an immediate if function that makes programming just a little easier and allows you to say things in much less lines. Consider the following...

    if Str = 'Top' then
        s := 'Woohoo!'
    else
        s := 'Climb some more';

While in Delphi we can effectively write this on one line as...

    if Str = 'Top' then s := 'Woohoo!' else s := 'Climb some more';

This looks untidy. If we were using another language with immediate if, that would look like this...

    s := iif(Str='Top', 'Woohoo!', 'Climb some more');

Now I realise to some Delphi programmers that are not multiple programming language experienced, all that seems a little esoteric but it is standard use in even Excel. Here's how it works...

iif(condition, TrueResult, FalseResult) : String;

The iif() function first looks at the boolean condition. If that condition is true, then it return the TrueResult, and if it is false, then it returns the FalseResult. Here's the declaration

function iif(Test: boolean; TrueR, FalseR: string): string;

The 1st parameter is the Test condition, this can be anything (e.g.: x > y).
The 2nd parameter is the string to return if the test condition is True.
The 3rd parameter is the string to return if the test condition is False.

Here's the full function...

function iif(Test: boolean; TrueR, FalseR: string): string;
begin
    if Test then
        Result := TrueR
    else
        Result := FalseR;
end;

but in other languages, the 'type' we return can vary. For example we may want to return 99 if true or 0 of false. How do we do that in Delphi? By using the 'overload' directive.

function iif(Test: boolean; TrueR, FalseR: string): string; overload;
function iif(Test: boolean; TrueR, FalseR: integer): integer; overload;
function iif(Test: boolean; TrueR, FalseR: extended): extended; overload;

Implementation

function iif(Test: boolean; TrueR, FalseR: string): string;
begin
    if Test then
        Result := TrueR
    else
        Result := FalseR;
end;

function iif(Test: boolean; TrueR, FalseR: integer): integer; 
begin
    if Test then
        Result := TrueR
    else
        Result := FalseR;
end;

function iif(Test: boolean; TrueR, FalseR: extended): extended; 
begin
    if Test then
        Result := TrueR
    else
        Result := FalseR;
end;

We can even extend these to bytes or even TObject if we want to. The only thing we can't do is have the same parameter types and return a different type, e.g...

function iif(Test: boolean; TrueR, FalseR: string): string; overload;
function iif(Test: boolean; TrueR, FalseR: string): integer; overload;

This is a no-no. Why? Delphi will decide which function to run based on the parameter types. If all the parameter types are the same, Delphi will not compile as it will see this as an error.

As already stated, Delphi decides which function it will used based on the types used in the parameters. It will always use the least type for the job. For example, if you have iif()'s set up for both integer and byte, and then use iif(x=y,5,10), then Delphi will use the byte function and return a byte. In most cases this will still work ok even if you are expecting an integer returned.Fonte: http://stevepeacocke.blogspot.com

Firebird Won 2 Sourceforge Community Awards

2007-08-15T19:37:00.000-07:00

From InfoWorld:
SourceForge unveils the winners of the ‘open-source Oscars’
“…The Firebird relational database was another double winner, being voted both best project for the enterprise and the project providing the best user support.”
Fonte: http://firebird-with-delphi.blogspot.com

Firebird 5th International Conference

2007-08-15T19:34:00.000-07:00

This years conference will be held in the Telekom Conference Hotel in Hamburg, Germany. There are different international flights to Hamburg. We recommend to check www.air-berlin.com with a lot of european destinations and very cheap pricing. Hamburgs international airport code: HAM http://www.ham.airport.de/index_en.phtml

There is a public train station nearby conference hotel. A map of the location with traveling infos will be send to all visitors

This year we have a special entry level track on thursday and friday. For advanced visitors you find a seperate thread. In the codecamp, you can ask on both days the experts and let them analyze your real world problem. On saturday you will find more general session topics.

Early bird conference fees (valid until 20th sep 2007):
-Full Conference Package 599 Euro *
3 days conference, 4 nights in the conference hotel
(17.-21.) , breakfast, lunch, dinner, evening events

-Conference Only Package 399 Euro *
3 days conference, lunch

-Main Conference Day only Package 169 Euro *
saturday only conference, 1 night in the conference hotel (20.-21.), breakfast, lunch, dinner, saturday evening event

-Main Conference Day only 99 Euro *, saturday only
conference, lunch

* all prices excl 19% VAT, required for all visitors 2nd visitor discount 10%, 3rd visitor discount 15% Please use the website www.firebird-conference.com or email info@h-k.de or fax +4970042397378 to send us your reservation. We hope to see you in Hamburg.

Naturally, we are still looking for sponsors! If you have been thinking about being a conference sponsor, NOW is the time to act. It is also possible to add special product sponsoring packages. Please contact hklemt@ibexpert.biz as soon as possible.

Taken from Firebird News

Fonte: http://firebird-with-delphi.blogspot.com

New site Firebird FAQ

2007-08-15T19:28:00.000-07:00

Hi guys, there is a new site for Firebird, it is Firebird FAQ
This site is built by Firebird users, for Firebird users to answer the most frequently ask question (FAQ). It's also has a good index to separate question topic. So if you want to know more about this fenomenal database, check it out :)Fonte: http://firebird-with-delphi.blogspot.com

Practical Development Methodologies

2007-08-15T15:33:00.000-07:00

Over the years I have designed and installed a number of development methodologies into various organisations (I'll not list them here). What I'm interested in is a description of the development methodology that is adopted by your company, why, and how well its working.

I'd also like to know your description of the development method, not just the company's blurb sheet. For example, I was once working for a company who was the major client of a software development company. I was asked to report on the development methodology that the software company had adopted and how well it was working in favour of the client.

The company, like a great many others I know, proudly advertised their methodology as "Agile". Agile is not itself a methodology but rather a concept. There are a number of methodologies which come within the concept of "Agile". Upon investigation, the company was operating under "Iterative and Incremental Development" (IID). After getting to know both the development company, and the client, I was able to report that the IID methodology worked exceedingly well for both the development company, and their major client in this case.

In most of the methodologies I have installed, I have yet to install a stock-standard, out of the book methodology. I much prefer to look at several areas within the company I am contract to, to ensure a good fit. These areas include:

How the programming team currently works, what works well and what needs improvement.
The major applications that the team completes, e.g. large developments that take longer than 6 months to deliver, or daily support and enhancements to legacy applications.
The major clients of the team. This may be serving in-house applications (in which case the customer may be another business area) or small, large, or corporate external customers. each has its own unique needs.
The slant that management wants to portray to the outside world.
Both the history and the perceived future of the development team.
The history and quality of the delivered products.
The location and proximity of the team. For example, some companies I have worked with perform all their development in India with local staff consisting of Business Analysis and Technical Architects. Others have split their development team between two cities.
The makeup of the team. Some teams may have 'prima donna' programmers that simply will not conform to changes unless they are subtle or suit their own needs.

All these will have an effect on the eventual development methodology that will be designed and installed.

One example of a change to the standard methodology was where I designed and installed a standard Waterfall methodology to cope with external programmers, but changed the process to be used for Functions, instead of whole applications. This reduced the time it took for the external programmers to return their first cut that could be tested and, where necessary, returned for minor alterations. This meant that for any application there were several waterfalls operating at any one time. A sort of RAD-ified, or even XP'd Waterfall.

So what's your advertised methodology? What's your actual methodology? How well does it work for the team? And how well does it work for the client/customer?

You don't need to tell me the company you work for, and in most cases it may not be prudent.Fonte: http://stevepeacocke.blogspot.com

The Shell Sort

2007-08-14T16:34:00.000-07:00

Yes, I know Delphi comes with a number of sorting routines, but I thought I'd describe a shell sort as it is fascinating little sort routine that is easily understood and a very fast routine.

[Steve: Although the "Shellsort" algorythm was first published by Donald Shell (as pointed out by Anthony Mills, thanks Anthony), this 'Shell Sort' uses a different approach that would be closer to a "Bubble Sort" with some changes. I therefore take a little 'artistic licence' in describing it in ways that people can visually understand]

The name "Shell Sort" comes from those games that are played by the magician, conman, or simply the swift of hand when they try to get money from the average passerby. Having usually 3 shells, a small coin or marble is placed under one of the shells. The shells are then swapped around at speed and the passerby is asked to bet on which shell contains the marble.

The shell sort routine does that same swapping around, but only to place all the shells in order. Consider that each shell is numbered, in this case, 1 to 5, but we'll first get our 'swift of hand' guy to jumble them up a little.

For the purposes of this blog, I'll limit the sort to only 5 integer numbers (or shells) although these could be words or extended reals or whatever. So long as you can compare them to see which is the greatest, this routine is the same or similar.

What this routine does is traverse the 5 shells many times. Each time, it will check each shell and see if it is greater than the next shell, if it is, it will swap the two shells. This will have the effect of moving the largest numbers to the right and the smaller numbers to the left - in other words, sorting them.

Consider the first time through, looking at each shell in turn, and swapping them with the next if it is larger, would, by default, move the largest number to the end.

Lets take a look at what will happen on the first run through.

35241 (look at 1st number, swap if 3 > 5)
35241 (look at 2nd number, swap if 5 > 2)
32541 (look at 3rd number, swap if 5 > 4)
32451 (look at 4th number, swap if 5 > 1)
32415

This moved the largest number (5) to the end. This means that the next time through, we would only need to look at the first 4 numbers, and so on until there is only one number left. That will tell us that the shells are sorted. BTW: Did you notice that we only stepped throuigh the first 4 numbers? That's because the last number is, well, it's the last number and doesn't have a next number to compare to.

Another way to know if they are all sorted (after all, we don't yet know if they are in order before we start) is if we traverse the shells and none needed to be swapped. If we didn't swap any then its in order and we can stop.

Let's start. Create a new project in Delphi with a form. Drop a TMemo and a TButton on the form. We'll put all the code on the OnClick event of the button, so we can follow it easier. First declare the counters; the shells themselves; and a true/false variable to tell us that no swaps were made during the last traversal.


var
    i, LastShell: integer;
    Shell : Array[1..5] of integer;
    NoSwap: boolean;

Then we'll place a procedure inside the OnClick event (something that I would not normally do, but we're keeping it all tight for you). This procedure will simply display the current state and order of the shells so we can see what's happening.


procedure ShowShells;
var
    i: integer;
    s: string;
begin
    // display the shell order in the TMemo
    s := '';
    for i := 1 to 5 do
        s := s + IntToStr(Shell[i]);
    Memo1.lines.Add(s);
end;

Go on, say ShowShells shix times quickly. Then we'll add another procedure. This one will swap a shell with the next and tell us that the swap occured.


procedure Swap(var First, Second: integer);
var temp: integer;
begin
    Temp := First;
    First := Second;
    Second := Temp;
    NoSwap := false;
end;

Note that I declared variable parameters, but I also could have swapped the array directly. Either way would have been acceptable in this situation.

Now we can start writing code in the OnClick event itself. First we'll fill the array with the current order of the shells.


begin
    Shell[1] := 3;
    Shell[2] := 5;
    Shell[3] := 2;
    Shell[4] := 4;
    Shell[5] := 1;
    memo1.Clear;
    ShowShells;

Now we can do the actual sorting, using the counters. Remember, we are going down in the number of shells we need to sort each time (the largest will move to the end each time).


    memo1.lines.add('now sorting...');
    for LastShell := 5 downto 1 do
    begin
        NoSwap := true; // No swaps this time through yet
        // traverse the unsorted shells 
        for i := 1 to LastShell-1 do
        begin
            if Shell[i] > Shell[i+1] then
                // its greater than next, swap them
                Swap(Shell[i], Shell[i+1]);
            ShowShells;
        end;
        if NoSwap then
            // we traversed the shells and didn't need to swap
            // any therefore its sorted and we can stop.
            break;
    end;
    memo1.lines.add('Done');
end;

Note that we only traversed the shells to LastShell-1? that's because we can't look to swap the lastshell with the next one as its the last shell :-)

Here's the full code...


procedure TForm1.Button1Click(Sender: TObject);
var
    i, LastShell: integer;
    Shell : Array[1..5] of integer;
    NoSwap: boolean;

    procedure ShowShells;
    var
        i: integer;
        s: string;
    begin
      s := '';
      for i := 1 to 5 do
          s := s + IntToStr(Shell[i]);
      Memo1.lines.Add(s);
    end;

    procedure Swap(var First, Second: integer);
    var temp: integer;
    begin
        Temp := First;
        First := Second;
        Second := Temp;
        NoSwap := false;
    end;
 
begin
    // assign numbers to the array
    Shell[1] := 3;
    Shell[2] := 5;
    Shell[3] := 2;
    Shell[4] := 4;
    Shell[5] := 1;
    memo1.Clear;
    ShowShells;
    memo1.lines.add('now sorting...');
    for LastShell := 5 downto 1 do
    begin
        NoSwap := true; // No swaps this time through yet
        // traverse the unsorted shells 
        for i := 1 to LastShell-1 do
        begin
            if Shell[i] > Shell[i+1] then
                // its greater than next, swap them
                Swap(Shell[i], Shell[i+1]);
            ShowShells;
        end;
        if NoSwap then
            // we traversed the shells and didn't need to swap
            // any therefore its sorted and we can stop.
            break;
    end;
    memo1.lines.add('Done');
end;

Fonte: http://stevepeacocke.blogspot.com

The Delphi/Pascal Sentence

2007-08-13T17:07:00.000-07:00

...or "When/Where to use semicolons".

Apologies to all you long time Pascal gurus, but in the last few days I was pondering on the advice I gave a few students learning Pascal and felt that Today's post should be directed at those learning the language.

Many new-comers find it difficult to grasp when they should be using a semicolon. The rules seem complex and inconsistant to them, when in fact they are reasonably consistant. Consider this...

"Pascal is a sentence"

Writing in Delphi Pascal is writing sentances, its that simple. Consider the following simple piece of code...

if x > 0 then
  ShowMessage('x is worth something')
else
  ShowMessage('x is worthless');

That equates to a sentence of "If x is greater than zero then x is worth something otherwise x is worthless.". Some people call that a Pascal statement, but I like to think of it as a sentence. Sentences are normally ended in a full stop, but in Pascal, sentances are ended in a semicolon and only the program is ended in a full stop. in the above Pascal sentence, the semicolon comes at the end as it should, and not half way through. You wouldn't say "If x is greater than zero. Then x is worth something. Otherwise. X is worthless." would you? That's 4 parts of a sentence that are seperated into 4 sentences that are meaningless.

So why can't we just place a semicolon before the else? Well think of it. If someone is talking to you in fluent english and finishes the sentence, then a little later (when you are thinking of something else), states "otherwise...", you would say "Huh? what do you mean 'Otherwise'". The Delphi Pascal compiler would state the equivelent of "Huh?" at that point and totally fail to understand you.

"OK-ish", I hear you saying "but what about all that begin/end stuff, nobody says that in real life", and normally you'd be right. Consider the following...


if x > 0 then
begin
  y := x;
  ShowMessage('x and y are the same');
  y := y * 10;
  ShowMessage('and now they are not')
end;

How does that equate to a sentence? Well, there is an overriding sentence there that says something like "If x is greater than zero then do some things...". (There's more to that sentence that I'll add soon).

You can think of begin/end as brackets if you like, that's what C and some other languages do, but Pascal is ever so slightly different. When speaking fluent Pascal (Pascal is a language after all), and you want to say some other sentences in the middle of your main sentence, you will need to let the listener know that by saying 'begin' and 'end'.

Each of the lines ending in a semicolon are their own sentences: "make y equal to x"; "say 'x and y are the same'"; "make y equal to y times 10". Being sentences in their own right, they can even have their own begin/ends for their sentences if they need them.

What about that last ShowMessage() statement? Well, here's where the Pascal sentence comes in. The overriding sentence actually says "If x is greater than zero then do some things and say 'and now they are not'.". More correctly, in fluent Pascal the true sentence is "If x is greater than zero then begin do some things and say 'and now they are not' end."

When speaking Pascal you do have to say the 'begin' and 'end' words in a sentence.

Now I can also hear you saying "but I have seen a semicolon before the 'end' many times". Yes, and pascal is smart enough to understand that you are saying nothing. Placing a semicolon before the 'end' is the equivilent of stating an empty sentence before finishing the outer sentence. Sweet nothings.

So what about Procedures and Functions? Procedures and functions are just teaching the Pascal language new words to use. For example...


Procedure Swap(var x, y: integer);

...says "I'm going to teach you the word 'Swap' and it will involve 2 whole numbers". Here's the full procedure which takes 2 numbers and swaps their values so that x equals what y did and y equals what x did (normally used in something like a simple shell sort) ...


Procedure Swap(var x, y: integer);
var i : integer;
begin
  i := x;
  x := y;
  y := i
end;

In this case, the sentence doesn't flow unless you expand it a little.

"Here's a new Pascal Word 'Swap' that takes 'x' and 'y' as variable parameters.
'i' is a new variable just for the word 'Swap'.
begin do some things and then make y equal i end.

The 'do some things' were some other sentences as you can see.

Are you now more confused than ever? Don't worry, that's normal, you are becoming a programmer after all :-)Fonte: http://stevepeacocke.blogspot.com

Use of Try/Except/Finally

2007-08-09T20:39:00.000-07:00

[Steve: I have altered the example to a more suitable one - that should teach me to quickly post then leave for the weekend without reading it].

I have seen a number of discussions recently showing that some developers can be confused over try/except and try/finally blocks. I can give an example in the kind of work that I was doing this morning.

I often read or write to an external device (let's just call it "the device" as it could be any external device). That device can sometimes send back confusing errors that I try to trap. However because those errors are confusing, I must let the user know all the various issues and ways around them.

Here's a simplified version of my code (the procedures can raise their own exception with the error message returned from the device).


var
    curSave         : TCursor;
begin
    try
        curSave := Screen.Cursor;
        Screen.Cursor := crHourGlass; // Show hourglass cursor
        try
            OpenDeviceConnection; // each will raise an exception if error
            DoStuffWithDevice;          
            ObtainReadings;
            CalculateNewFigures;
            UpdateDevice;
            If not CloseConnection then // raise my own error
                raise exception.create('Cant Close Connection');
        finally
            // return the cursor to what it was
            Screen.Cursor := curSave; 
        end;
    except
        // the original exception is now being handled
        // we can re-raise it, but in this case we'll
        // raise a new exception with additions
        on e:exception do 
            raise exception.create(e.message + #13+#10
               + 'Please check that the device is switched on' +#13+#10 
               + 'and that the cables are properly connected.'); 
    end;
end;

Exceptions created by any of the procedure calls will now result in an error message something like the following...

Note that I have also placed a try/finally block inside the try/except. This is to ensure that we get the cursor back.

I can raise an exception myself with "raise exception.create", the process then heads immediately to the except block, but before doing that, it must complete the finally block.

The order that finally and except will be executed depends on the order that you give it. In the above sequence, finally will be completed before the except. Usually you will see them the other way around where the exception is processed before the finally block.Fonte: http://stevepeacocke.blogspot.com

More on Delphi's early days

2007-08-01T16:04:00.000-07:00

My last post generated a bit of discussion, so I was trawling through the websites looking at the early Turbo Pascal information and I came across some interesting tidbits.

As has already been pointed out by one of the readers, there was life even before turbo Pascal. The Pascal Wiki states:

"In the 1980s Anders Hejlsberg wrote the Blue Label Pascal compiler for the Nascom-2. A reimplementation of this compiler for the IBM PC was marketed under the names Compas Pascal and PolyPascal before it was acquired by Borland ... renamed to Turbo Pascal."

Here are a few pages that I found that are worthy of looking into:

Antique Software: Turbo Pascal v1.0 - you can even download the IBM-PC version
Turbo Pascal - a short history of Turbo Pascal before it became Delphi
Brief descriptions and photos of Turbo Pascal versions
A more detailed history from About.com
CodeGear has a number of historical documents that you can browse

By the later 1980's I dropped the Turbo Pascal IDE in favour of MultiEdit. Its still around, and I still use it on occasion, but the Delphi IDE no longer needs it.

A reader in my last post pricked a memory or two over the character "Frank Borland". On searching, I came across this CodeGear piece about Frank. It is definately worth a read.

Ok, now playtime is over and I must get back to work.

Fonte: http://stevepeacocke.blogspot.com

Delphi/Pascal Through the Ages

2007-07-30T16:34:00.000-07:00

(I apologise that this is a long post. if you are in a hurry, then please at least read the last 3 paragraphs)

Delphi started out life as Turbo Pascal on CP/M. For those of you old enough to remember, CP/M was prior to MS-DOS, which in turn was prior to Windows. While getting to grips with Pascal MT+, I saw an add for a new compiler called Turbo Pascal in the very early 1980's and I bought myself a copy.

From this simple, small and very fast compiler I wrote a small business accounting program that I sold on the Amstrad Computer. I used some code I found in another Borland addition called 'Database Toolbox' to add file and indexing routines.

It was about mid 1980's that my accounting program The Trader Series had a serious following in New Zealand amongst Amstrad computer users and I decided to devote all my time porting it to MS-DOS, I gave up my job as Marketing Manager for Panasonic Computers in New Zealand to become a programmer. Coding in Turbo Pascal was fun. There were several enhancements since that first version 1 that I purchased, these included such powerful things as Overlays. We were restricted to 640 Kilobytes of memory so using overlays I could now write much larger programs.

There were also a lot of third party programs and additions around, including a simple debugger which helped me a great deal. "The Trader Series", the accounting program I wrote, expanded to five separate modules and over half a million lines of code. Having much greater access to memory, I totally rewrote the screen handling so that all screens were built in memory and "shifted" to the screen, making it seem lightening fast for the user. I also abandoned Turbo Toolbox and rewrote the indexing system with a doubly linked, self-balancing B++ tree. These enhancements, along with using linked lists for transactions made it the fastest accounting program on the market at the time.

I remember running a demo for the company I selected to distribute the program (I decided that I can't be both a programmer and salesman/marketing person). Their high end product took as much as 30 to 40 hours to run an end of month process. I had built up a database of 30,000 debtors, each with about a dozen transactions. After the demo they asked me to perform an end of month and turning to leave, asked when I would be back in to see the result. I told them it had been done. I spent all afternoon proving that it could run an end of month process in less than a minute. That program won the New Zealand Computer Software Awards in 1987 and became New Zealand's largest selling small business accounting program for the next 10 years.

Turbo Pascal was a great language. Object Pascal raised its head in version 4.0 and I stayed with Turbo Pascal until I sold The Trader Series in 1990.

By now Windows was getting a grip and I needed to move into this arena. Borland's Pascal for Windows just didn't do it for me. I went with a number of other languages including FoxPro, C++, Visual Basic, and I even tried a new language called Java (it'll never amount to anything but hype, or so I thought - Sigh, I have been proven wrong before).

Borland then introduced Delphi and I managed to get myself a pre-release copy. Finally a great environment. Something that equaled the environment of Turbo Pascal when it was first introduced. Delphi however had a much larger price tag, but I purchased anyway and was thrilled with the power that even this first release had. Delphi was written in Object Pascal and the source code was included. You could learn lot with that source code and programmers were able to write their own components. The Component market was created with many outstanding components pretty soon there were thousands to choose from.

Delphi, the new Turbo Pascal, was alive and kicking again. I was a contractor through the 1990's and contracted to many different companies and corporations and was able to persuade more than a few to look at Delphi for their future needs (where appropriate).

While Delphi was indeed an excellent development environment, I was more and more disappointed in its growing price tag. By 2003, Borland had priced itself completely out of the market. The price for Delphi was now about the same price as a good second hand car in New Zealand and more than almost all other development environments.

I could no longer afford my favourite development language and companies everywhere in New Zealand were coming to the same conclusion. Sadly, I was shifting to Microsoft and C#. I still had, and still use, Delphi 7, but the call to C# was strong as the companies left Borland, and as Borland lost interest in Delphi. I could not find work as a Delphi contractor any more.

Earlier this year, I was invited along to the Delphi 2007 pre-release roadshow. There I learned that Borland had shifted Delphi into a separate company and concentrated on its team tools. CodeGear had been created to take over Delphi as its flagship product. Personally I thought it should have been the other way around, but that's the way it is. The price of Delphi was dropped by several thousand from what it was in 2003, and it had been given several enhancements since I last saw it in Delphi 7.

I saw this as a resurrection of Delphi and a possible push to get Delphi back to its space as one of the top programming environments. They have a long way to go to get back the loyalty that they once had. Companies had dropped them and now few companies will look at Delphi again.
However, in my intervening years with other development environments I have learned a few things: A team of 3 dedicated Delphi developers can totally outperform a team of 40 developers in Java and other Microsoft languages for a similarly large corporate application - by a factor of several months. I have also learned that, although Delphi can do .NET, Win32 can often deliver to the customer a far superior product, much more aligned with the customer's needs, in a much reduced timeframe/cost. And I learned that even a single developer armed with some excellent Delphi tools, can take on the giants.

CodeGear, your work now is not with enhancing Delphi (other than in the helpscreens), its marketing that will win the lost corporates and large companies back. You won't win them all, the "We're a Microsoft Shop" syndrome is too well entrenched for that. But you can win over a lot and make your headway in the world again, and give back the power to the average programmer.

I must admit, it's nice to be able to get back to programming without fighting the tool every single step of the way.Fonte: http://stevepeacocke.blogspot.com

Getting the Time to Program

2007-07-24T13:53:00.000-07:00

How many others have the same problem?

I have a number of ideas that I would love to program in my spare time. I have produced many retail programs previously with success so know the pitfalls. I have worked out most of the kinks in the logic of how to implement many of the features. I just need to program them.

The problem is that I spend a great many hours in the day programming at work. New Zealand is known for being a wonderful place to live, but its also getting known as the hardest working. Us poor Kiwis (the kiwi is our native bird and also the name we call ourselves), have the second highest rate of average hours worked per year compared to all other OECD countries. This means that when I get home, I am in serious need of relaxation and the things I want to program get put off for another night.

I have some wonderful ideas that I know will be good sellers, I just need the time to program them. Often the time I do spend on these ideas at home, ends up as code that is used in my work programs. This keeps the boss happy (I hope), but doesn't get my programs finished.

Mind you, with spending every weekend with my Fiance and her daughter, and spending about an hour on the phone to her every night (we live in different towns) does not help the situation so I suppose I'm my own worst enemy.

How do you make sure that you put aside the time and energy to program in the evenings?Fonte: http://stevepeacocke.blogspot.com

Different Programming Styles

2007-07-18T15:46:00.000-07:00

I was reading Serge’s Blog on Programmers and Temperaments this morning and it reminded me of a project I did for a company in Wellington once. It was a large international company (no, I'm not going to tell you which) and they had a very large project that they needed to produce. The project was technically difficult requiring a lot of thought each step of the way.

After a lot of design by their chief software architect, they called for programmers. About twelve of us were hired for this one project and it was really fun to get to work with a number of others on one project like that. We were given regular daily meetings to try to bring us all up to speed on the technical requirements, and then shown to a large, open plan room with a computer on each desk to choose our own work area.

What was most interesting though was a discussion that I was having with the project manager about a week later. He commented on the work styles of each of the programmers from the perspective of an observer. This wasn't a moan or gossip session, but a discussion on a real observation.

After all the meetings and the whiteboard sessions were over, we all drifted into the desks and work practices we wanted. The project manager observed the following different styles...

I found my niche in a corner desk that was on its own, then got out my pad and spent the next 2 days planning what and how I was to approach my part of the project, before I even touched the keyboard. I wanted to completely understand the requirements (which were mostly in the architect's head, given out on the whiteboard sessions). Once I understood and had a clear plan, then it was a matter of programming.

Two others immediately grabbed two desks that were joined to each other so they were sitting side by side, then simply pulled one chair over to the other desk to together at the same desk, one computer between them, and designed and programmed together. They needed to talk through what they were doing and help each other plan and program. Occasionally the second programmer would move to the computer on the other desk to program a sample procedure to help explain to the other his thoughts on a subject.

Another programmer sat down at the first available desk and started pounding out code. He needed to try out various prototypes and work from there, building up his code as he went.

Various others worked somewhere along the spectrum of the above three different styles. Some couldn't handle it and after a few days left for greener and much easier pastures.

What was interesting over the following several months was the general effectiveness of the different styles. I (admittedly somewhat surprisingly as there were some seriously experienced programmers that I enjoyed working with) ended up producing the end result much faster, followed by the pair/buddy approach. The person who immediately started coding, had to change and restart so many times that he turned out to be the least effective.

I'd love to hear your comments on what you have found in your experiences.

Fonte: http://stevepeacocke.blogspot.com

My Delphi 2007 program isn't debugging!

2007-07-09T16:43:00.000-07:00

I think I've just found a little "think first" when using Delphi 2007.

Trying to step through the code with the debugger to find out how and why something isn't happening as it should, I placed a break point on the first line of my FormCreate method. When I ran the application in debug mode, my breakpoint changed to a green cross and the program didn't stop.

Aha! said I to myself thinking myself clever (always a mistake), It's a project option. I must have turned off the debugger. Nope - that wasn't it.

Aha then! (yes, clever again) I must have changed some other compiler directive somewhere. Nope - stumped.

Realisation is now dawning on me that I wasn't half as clever as I thought I was and I eventualy even reverted to the old "Microsoft's fault" fix-all - Exit Delphi and all other programs, close down and start the whole computer up again. Load up Delphi, place the breakpoint, run and ... Nope - that wasn't it either.

Several minutes of frustration followed in which it would not be prudent to relate all the details (I am Christian after all).

Then it dawned on me. A small 'thank-you' to Him and off I go to Project Options, Build Events. Yes, I had a Post-Build event.

My normal process is to build the application, then move the application to the ..\bin directory where it needs to be in order to run correctly. Being exceptionally clever (or so I thought at the time), I placed those steps into the Post Build event. That was several weeks ago and I had forgotten.

In order to correctly debug the program today, I changed the project's output Directory to the ..\bin directory where it needed to be to run.

What all that meant was that when I ran build (F9), I expected the program to run to the breakpoint and then stop. However, Delphi knew that I wanted some things to happen in the Post build routine and copied over the just-built exe with an older version sitting in the ..\source directory. Now there is an exe running that does not have the breakpoint and does not relate to the code I am expecting to run.

A interesting morning's lesson on trying to be too clever for my own good.

Have a great day.

SteveFonte: http://stevepeacocke.blogspot.com

Vote for Firebird in Sourceforge Awards

2007-07-08T20:18:00.000-07:00

Firebird is a finalist in four categories of the Sourceforge
Community Choice Awards for 2007.

In each category the Firebird project is up against 9 other
projects all selected for excellence from hundreds of thousands of SF
projects. Categories are Best Tool or Utility, Best Project for the
Enterprise, Best User Support and Best Project Overall.

Voting is open until July 20 so take this opportunity to credit
Firebird with your recognition. Full details and links here:

http://sourceforge.net/community/index.php/landing-pages/cca07/

Fonte: http://firebird-with-delphi.blogspot.com

FB Date Manipulation

2007-07-05T22:24:00.001-07:00

Last week I have a question from Delphindo (Indonesian Delphi community) thorough YM conference. The question is how to make SQL query for Firebird to obtain the same result as we do this (to_char(sysdate, 'YYMM');) in Oracle. I must admit that Firebird doesn't have this "to_char" built in function, but we can create the same result with the trick like this:

select current_date,
substring(extract(year from current_date) from 3)||
case
when char_length(extract(month from current_date))=1
then '0'||extract(month from current_date)
else
extract(month from current_date)
end as Year_Month
from rdb$database

Thank's to the new feature of Firebird 2, that can make this happen without installing any UDF. I use the "char_length" and "substring" built in function that come in Firebird 2 (version 1.5xx still not support this built in function).

Fonte: http://firebird-with-delphi.blogspot.com

Nice Function Added in Firebird 2.1 (beta)

2007-07-05T22:24:00.000-07:00

Here is the list of built in function in Firebird 2.1 (now, it's still beta). My favourite function:

String function: LPAD, RPAD, LEFT, RIGHT, POSITION, REPLACE, REVERSE

Date function: DATEDIFF, DATEADD

Numeric function: ROUND, TRUNC, ABS, MIN_VALUE, MAX_VALUE, GEN_UUID, HASH

So with this new built in function, my previous article can be achieve with more short statement like this:

select current_date,
right(extract(year from current_date), 2) ||
right('0' || extract(month from current_date), 2) as Year_Month
from rdb$database

But in my opinion it would be nice if Firebird team extend the capability of SUBSTRING function like this: the "length" value can be negative so it can achieve the same result like RIGHT function with the capability of "start position". Example:

Substring('Hello World' from 9 to -3) will result "Wor"

Fonte: http://firebird-with-delphi.blogspot.com

Firebird 2.1 is in Alpha state

2007-07-05T22:23:00.001-07:00

Here is the link of release note FB2.1Alpha. Wow it's time to try.
Some cool feature:

Use of domains for Trigger/SP variable definition (SQL Server or MySQL doesn't have it (CMIIW))
Global temporary tables
Common table expressions, recursive queries
Database Triggers
Database Monitoring via SQL
Admin information via select
Get ODS Version and Dialect via SQL

Fonte: http://firebird-with-delphi.blogspot.com

Firebird Date Literals

2007-07-05T22:23:00.000-07:00

Today I go to firebirdnews and found that this article is good and it may guide you to know more about FB date time. Here is the linkFonte: http://firebird-with-delphi.blogspot.com

Backup in Firebird

2007-07-05T22:22:00.001-07:00

There is nice article in here that explain a lot of things about backup database in Firebird (including command reference). This article is lack of explanation about Firebird new incremental backup (but you can find about this incremental backup on your Firebird 2 release notes). Hope you like it.Fonte: http://firebird-with-delphi.blogspot.com

Firebird 2.0.1 and ZeosDBO 6.6.1 beta

2007-07-05T22:22:00.000-07:00

Yeah I know it's late to let you know thorough this Blog that Firebird 2.01 and ZeosDBO 6.6.1 beta is released, but if you don't know then I hope this little blog can let you know more.

Firebird 2.0.1 is only bug fixed and there is nothing new feature.
ZeosDBO 6.6.1 beta is only bug fixed and there is nothing new feature.Fonte: http://firebird-with-delphi.blogspot.com

Recomended Page Size in Firebird

2007-07-05T22:21:00.000-07:00

If you using Firebird database then the best setting for id set the page size to 4096 and use SQL Dialect 3Fonte: http://firebird-with-delphi.blogspot.com

FB2.0 New Interesting Feature

2007-07-05T22:20:00.000-07:00

Today, I just know after reading my email from firebird-support that show the new feature of FB2.0 the complete article can be found here but that article is not in English :( (If someone here know what language in that site is used, please tell me because I want to translate it using Altavista Babel fish) I just read the example from that article and try it. The one that I like, is the new function on ODS 11 and it can be used like this:

select rdb$get_context('SYSTEM', 'NETWORK_PROTOCOL') as protocol
    , rdb$get_context('SYSTEM', 'CLIENT_ADDRESS') as client_address
from rdb$database;

In ODS 11 we have the built in UDF rdb$get_context and rdb$set_context you can read more information from the doc directory that come with FB2.0 the file is:

"README.context_variables2.txt"Fonte: http://firebird-with-delphi.blogspot.com

Upgrading Firebird 1.5 to 2.0

2007-07-05T21:34:00.000-07:00

Yeah, last week I try to install the new Firebird 2.0. And it's easy to migrate the old ODS 10.1 (FB 1.5) to ODS 11 (FB2.0) what you need to do is:

1. Uninstall Firebird 1.5.3 (if yu wish not to use it again)
2. Install the Firebird 2.0
3. Backup your old database with this new gbak from FB2.0
4. Restore them back with gbak from FB 2.0
5. Now you have the new database with ODS 11

Hope this little article can help you :)Fonte: http://firebird-with-delphi.blogspot.com

Firebird 2.0 is Out, what about me?

2007-07-05T21:33:00.001-07:00

On 13 November 2006 Firebird 2.0 is launch on the opening of Firebird Conference. I already download it, but I'm still using version 1.5.3 for my real application and just try version 2.0 in my research computer. Why? because I still wait for the version 2.1 =) As you know usually the early version still have a bug or the feature that is not yet complete. But if you are a new Firebird user then you must download this 2.0 and evaluate it. I still wait for the roadmap of the Firebird development that usually out after the Firebird conference to see what feature that I neeed most for my current project. It's happy to see that this community so activeFonte: http://firebird-with-delphi.blogspot.com

ReInstalling Component That Using ZeosDBO 6.6 beta

2007-07-05T21:33:00.000-07:00

Today I try again to ReInstall my components that using ZeosDBO. I want to try this new beta version (version 6.6 beta) so I must clean up my past ZeosDBO 6.1.5. The difficulty that I found when intalling version 6.6 beta is that the seacrh directory and the output directory (from the ZeosDBO.bpg) must be set first (so It's not easy installation for Delphi user that just learn how to install Delphi components), I think they will fix this later for stable version (as they did for 6.1.5 version).

The point is this new version has a simple bpl & dcp created. Before version 6.6 there is many bpl & dcp respectively for the "ZComponent", "ZCore", "ZPlain" and others. But in this 6.6 version the bpl & dcp is only "ZComponentDesign.dcp" and "ZComponentDesign70.bpl" so I must delete the requires dcp for my components and replace with this new dcp. That's all and everythings goes well (of course after I fix the property "RequestLive" with "ReadOnly")Fonte: http://firebird-with-delphi.blogspot.com

Explicit Cursor in Firebird PSQL

2007-07-05T21:30:00.001-07:00

Explicit cursor is a new this in Firebird because it's only available in version 2. We can found this syntax in the release notes on Stored Procedure Language (PSQL) section. The example below is taken from that release notes


DECLARE RNAME CHAR(31);
DECLARE C CURSOR FOR ( SELECT RDB$RELATION_NAME FROM RDB$RELATIONS );
BEGIN
 OPEN C;
 WHILE (1 = 1) DO
 BEGIN
   FETCH C INTO :RNAME;
   IF (ROW_COUNT = 0) THEN
     LEAVE;
   SUSPEND;
 END
 CLOSE C;
END

Fonte: http://firebird-with-delphi.blogspot.com

Implicit Cursor in Firebird PSQL

2007-07-05T21:30:00.000-07:00

Firebird has an implicit cursor, we can found the example in the example database employee.fdb, and we can find in the "DEPT_BUDGET" stored procedure, lets look into the source, the implicit cursor has the syntax:


FOR [select statement] into [local variable that hold the value from select]
DO
BEGIN
 [your statement]
END

The local variable is must defined for each of the field that selected and remember the datatype must be the sameFonte: http://firebird-with-delphi.blogspot.com

Sweeping

2007-07-05T21:28:00.000-07:00

Sweeping is NOT just organized garbage collection. What sweeping seeks to do is to move the Oldest Interesting Transaction up, and reduce the size of transaction masks. It does so by changing rolled back transactions to committed transactions.

"What!!!", you say. "The woman is nuts."

But that's what a sweep does. It removes all the changes made by a rolled back transaction then changes it state to committed. (Remember we agreed earlier that a read-only transaction that rolled back could be considered committed for all the harm it did. Remove the damage, and its safe to consider the transaction committed.)

At the same time, sweep garbage collects like any other transaction.

A new thread is started and sweeps the database while everybody else goes about life as normal. Well, more or less normal, where the less is the amount of CPU and I/O bandwidth used by the sweep.

Taken from IBPhoenixFonte: http://firebird-with-delphi.blogspot.com