Since for some strange reason I couldn't fit everything in a single post, I had to split it up, so this is the rest of it

The TdvStringSetting class

The explanation

Basically the TdvSetting provides us with a skeleton we can use for our new Setting descendants. I ended up with a TdvStringSetting, TdvIntegerSetting, TdvBooleanSetting and quite a few others, but lets start with the TdvStringSetting first.

The Code

  TdvStringSetting = class( TdvSetting )
  private
    function GetDefaultValueAsString: String;
  protected
    function GetAsBoolean: Boolean; override;
    function GetAsDateTime: TDateTime; override;
    function GetAsFloat: Double; override;
    function GetAsInteger: Longint; override;
    function GetAsString: string; override;
    function GetAsVariant: Variant; override;

    function GetValue(var Value: string): Boolean;

    procedure SetAsBoolean(const Value: Boolean); override;
    procedure SetAsDateTime(const Value: TDateTime); override;
    procedure SetAsFloat(const Value: Double); override;
    procedure SetAsInteger(const Value: Longint); override;
    procedure SetAsString(const aValue: string); override;
    procedure SetVarValue(const aValue: Variant); override;
  public
    procedure SaveToRegIni  ( aRegIni : TRegistryIniFile; const aSection : String ); override;
    procedure LoadFromRegIni( aRegIni : TRegistryIniFile; const aSection : String ); override;

    property DefaultValue  : String       read  GetDefaultValueAsString;
    property Value         : string       read  GetAsString
                                          write SetAsString;
  end;

...

{ TdvStringSetting }

function TdvStringSetting.GetAsBoolean: Boolean;
var
  S: string;
begin
  S := GetAsString;
  Result := (Length(S) > 0) and (S[1] in ['T', 't', 'Y', 'y']);
end;

function TdvStringSetting.GetAsDateTime: TDateTime;
begin
  Result := StrToDateTime(GetAsString);
end;

function TdvStringSetting.GetAsFloat: Double;
begin
  Result := StrToFloat(GetAsString);
end;

function TdvStringSetting.GetAsInteger: Longint;
begin
  Result := StrToInt(GetAsString);
end;

function TdvStringSetting.GetAsString: string;
begin
  if not GetValue(Result) then Result := '';
end;

function TdvStringSetting.GetAsVariant: Variant;
var
  S: string;
begin
  if GetValue(S) then Result := S else Result := Null;
end;

function TdvStringSetting.GetDefaultValueAsString: String;
begin
  Result := FDefaultValue;
end;

function TdvStringSetting.GetValue(var Value: string): Boolean;
begin
  Value  := FValue;
  Result := True;
end;

procedure TdvStringSetting.LoadFromRegIni(aRegIni: TRegistryIniFile;
  const aSection: String);
begin
  inherited LoadFromRegIni( aRegIni, aSection );

  Value := aRegIni.ReadString( aSection, Identifier, DefaultValue );
end;

procedure TdvStringSetting.SaveToRegIni(aRegIni: TRegistryIniFile;
  const aSection: String);
begin
  inherited SaveToRegIni( aRegIni, aSection );

  aRegIni.WriteString( aSection, Identifier, Value );
end;

procedure TdvStringSetting.SetAsBoolean(const Value: Boolean);
const
  Values: array[Boolean] of string[1] = ('F', 'T');
begin
  SetAsString(Values[Value]);
end;

procedure TdvStringSetting.SetAsDateTime(const Value: TDateTime);
begin
  SetAsString(DateTimeToStr(Value));
end;

procedure TdvStringSetting.SetAsFloat(const Value: Double);
begin
  SetAsString(FloatToStr(Value));
end;

procedure TdvStringSetting.SetAsInteger(const Value: Integer);
begin
  SetAsString(IntToStr(Value));
end;

procedure TdvStringSetting.SetAsString(const aValue: string);
begin
  FValue := aValue;
end;

procedure TdvStringSetting.SetVarValue(const aValue: Variant);
begin
  SetAsString(aValue);
end;

What does it do ?

Since we had the skeleton of the TdvSetting in place, the only thing we needed to do was to override the necessary methods and implement our own features. As you can see, we added approximately the same code as can be found in the TStringField in the VCL.

The only additional code is the implementation of the SaveToRegIni and LoadFromRegIni methods. These methods will actually load and save the value of the Setting to the Registry. Additionally when loading the value we will be using the Default value if the setting can't be found in the regsitry. The Section where we will read / write the value can be supplied to the method and we will be using the identifier (name) of the setting as the key

Creating the TdvSettings class

The explanation

Well, now that we can make different type of Setting objects, we also need some kind of container to hold them. For example our application might have quite a few settings : PrintInColor, CheckForUpdates, AutoConnect, ... but we will need some way to access them. As mentioned before I created the TdvSettings class as a simple TObjectList. It will hold a reference to the individual TdvSetting objects and we will be able to access them

The Code

  TdvSettings = class( TObjectList )
  private
    FRootKey: String;
  protected
    procedure CreateSettings; virtual;

    function GetItems(Index: Integer): TdvSetting;
    procedure SetItems(Index: Integer; ASetting: TdvSetting);
  public
    constructor Create( const aRootKey : String );

    function Add(ASetting: TdvSetting): Integer;
    function Extract(Item: TdvSetting): TdvSetting;
    function Remove(ASetting: TdvSetting): Integer;
    function IndexOf(ASetting: TdvSetting): Integer;
    function First: TdvSetting;
    function Last: TdvSetting;
    function SettingByIdentifier( const aIdentifier : String ) : TdvSetting;

    procedure LoadFromRegistry;
    procedure SaveToRegistry;

    procedure Insert(Index: Integer; ASetting: TdvSetting);
    property Items[Index: Integer]: TdvSetting read GetItems write SetItems; default;
    property RootKey : String read FRootKey write FRootKey;
  end;

  ...

{ TdvSettings }

function TdvSettings.Add(ASetting: TdvSetting): Integer;
begin
  Result := inherited Add(ASetting);
end;

constructor TdvSettings.Create(const aRootKey: String);
begin
  inherited Create( True );
  FRootKey := aRootKey;
  CreateSettings;
  // Read the settings from the Registry once the Settings object list has
  // been initialised.
  LoadFromRegistry;
end;

procedure TdvSettings.CreateSettings;
begin

end;

function TdvSettings.Extract(Item: TdvSetting): TdvSetting;
begin
  Result := TdvSetting(inherited Extract(Item));
end;

function TdvSettings.First: TdvSetting;
begin
  Result := TdvSetting(inherited First);
end;

function TdvSettings.GetItems(Index: Integer): TdvSetting;
begin
  Result := TdvSetting(inherited Items[Index]);
end;

function TdvSettings.IndexOf(ASetting: TdvSetting): Integer;
begin
  Result := inherited IndexOf(aSetting);
end;

procedure TdvSettings.Insert(Index: Integer; ASetting: TdvSetting);
begin
  inherited Insert(Index, aSetting);
end;

function TdvSettings.Last: TdvSetting;
begin
  Result := TdvSetting(inherited Last);
end;

procedure TdvSettings.LoadFromRegistry;
var
  lIndex   : Integer;
  lSetting : TdvSetting;
  lRegIni  : TRegistryIniFile;
begin
  lRegIni := TRegistryIniFile.Create('');
  try
    for lIndex := 0 to Pred( Count ) do
    begin
      lSetting := Items[ lIndex ];
      lSetting.LoadFromRegIni( lRegIni, RootKey );
    end;
  finally
    FreeAndNil( lRegIni );
  end;
end;

function TdvSettings.Remove(ASetting: TdvSetting): Integer;
begin
  Result := inherited Remove(aSetting);
end;

procedure TdvSettings.SaveToRegistry;
var
  lIndex   : Integer;
  lSetting : TdvSetting;
  lRegIni  : TRegistryIniFile;
begin
  lRegIni := TRegistryIniFile.Create('');
  try
    for lIndex := 0 to Pred( Count ) do
    begin
      lSetting := Items[ lIndex ];
      lSetting.SaveToRegIni( lRegIni, RootKey );
    end;
  finally
    FreeAndNil( lRegIni );
  end;
end;

procedure TdvSettings.SetItems(Index: Integer; ASetting: TdvSetting);
begin
  inherited Items[Index] := aSetting;
end;

function TdvSettings.SettingByIdentifier(
  const aIdentifier: String): TdvSetting;
var
  lcv : Integer;
begin
  Result := Nil;

  for lcv := 0 to Pred( Count ) do
  begin
    if ( Items[ lcv ].Identifier = aIdentifier ) then
    begin
      Result := Items[ lcv ];
      Break;
    end;
  end;
end;

What does it do ?

Well, it is simply a container for a number of TdvSetting objects. It has some basic code which will allow us to access the individual TdvSetting objects using their index or their Identifier (name). We will be able to set the RootKey of the TdvSettings object and that is the base key which will be used when loading / storing the individual TdvSetting objects.

You willl notice that I added a CreateSettings method which is currently empty. The goal is to implement this in descendant classes. At the TdvSettings level we don't yet know which individual settings we will need, how they are called and what type they are ... Yet, I wanted to be able to create those settings from within the base class and once that is done read the settings if necessary.

In my TdvMyApplicationSettings I will override this method and add the necessary code to set up the individual TdvSetting objects I need for my applicaiton.

What's next ?

Currently we have a basic skeleton in place and we are able to continue from here. If you're up for a challenge, you might want to create your own TdvSetting descendants. I noticed I needed one for Integer values, DataTime values and Boolean values, so you could try to implement those.

As I mentioned at the end of the previous article, this isn't the only way, nor THE way to solve this problem, and I actually did try a few other approaches as well. It did take me a few iterations to get to this stage. For example, initial versions had the actual code for creating the TRegistryIniFile class inside the individual TdvSetting objects.

Quickly I noticed though that I had the exact same code in all my TdvSetting descendants LoadFromRegIni and SaveToRegIni methods so I started thinking again. I thought that constructing & destroying the TRegistryIniFile might be something I don't want to execute for the 20 individual application settings so I ended up refactoring the code to it's current status

Feedback

I'm quite sure the code could be simplified and maybe improved, and I do welcome all suggestions and feedback. So feel free to post all comments on this blog and I'll try to respond ASAP. Maybe your feedback will shape the next article in this series ...

So, basically we need a class / object which we can use to read and write some application settings from and to the Windows Registry. Sounds pretty straightforward ... but we did some additional thinking and found out that we might need to add some stuff in the future.

Basic Requirements of the code

Compatibility with Delphi 7

Although quite a few new features were added to the language in the last years, we won't be using them 'yet'. Our goal is that the code should compile / work under Delphi 7.

You may be asking yourselves "Who going though all that trouble for an old Delphi version ?", well I noticed that even today some of my clients still have older projects which get compiled in Delphi 7. In later articles I might show you how to do it using some newer techniques, but for now lets just stick with something that will compile under Delphi 7

Not limited to the Windows Registry

Although we will be writing the code based on using the Windows Registry to Load and Save our data. We want an easy way to adapt our code for some other things like storing the data in XML or an Ini file. After all, we don't know what the future will bring yet. We might be able to build applications for Windows Mobile, the Mac, iPhone or even iPad in the future (Would that be nice), and the Windows Registry might not be available on those devices.

For now we will focus on the Windows Registry, but as you notice it is a good idea to keep a few other possibilities ready. In the end, the only thing we care about is that we can store / load some settings. How or where these settings are stored isn't all that important, it just needs to get done !

Additional Things

So far, we know we will need something to hold a set of settings. We need to be able to load and save those settings. We will probably be supplying a name for each individual setting, maybe even a default value and a description. We need to be able to store Integers, Strings, but who knows even Passwords, Dates, ...

Lets get Coding !

... well almost ...

Well, ... actually before we start coding we could take a look at how some of these things get solved in the VCL. Of course, we could do all the coding ourselves, but it might be a good idea to let our new classes inherit from some existing classes. Since we need a list of things, you might want to take a look at the TList for example.

In my case, I knew I want to have a Setting which I will use to store Strings, one to store Integers and another one to store Booleans. Once I had those, I quickly noticed I wanted some others for DateTime values and quite a few other things as well. I actually ended up doing something quite similar to TField and TIntegerField, TStringField, ...

So, now that I know I will be using different types of Setting objects and I want to keep a list of those Setting Objects, I quickly decided that the TObjectList was a very good class to start with.

Creating the TdvSetting class

The explanation

Basically I need an object with a few properties like an Identifier (or Name, Caption), a Description (or Hint) and of course a Value. I will need to be able to read the value from the Registry and write it to the registry. Additionally when reading the value from the Registry I want to check if there is already something in the registry for the setting, and if nothing is found, the Default value should be used.

Just as with the TField and TStringField, I want to be able to get the Value of the TdvSetting as a String or as a Variant, so I added that code as well. Additionally I want to set the value of the TdvSetting as well. In the end, the descendant classes will implement most of this, but like with the TField in the VCL, I added some code which will raise an exception if a descendant class doens't implement a specific accessor.

This might sound a bit complex, but lets compare it with the TField and TStringField again. With a TStringField, you can set the value using aField.Value := theValue or with aField.AsString := theValue. Both things will work, but if aField is in instance of TField instead of TStringField an exception will be raised. What I did was implement that functionality as well.

For now we will focus on the Windows Registry, but as you notice it is a good idea to keep a few other possibilities ready. In the end, the only thing we care about is that we can store / load some settings. How or where these settings are stored isn't all that important, it just needs to get done !

The Code

  TdvSetting = class( TObject )
  private
    FValue        : Variant;
    FDefaultValue : Variant;
    FIdentifier   : String;
    FCaption      : String;
    procedure SetCaption(const Value: String);
    procedure SetVisible(const Value: Boolean);
  protected
    function GetAsBoolean: Boolean; virtual;
    function GetAsDateTime: TDateTime; virtual;
    function GetAsFloat: Double; virtual;
    function GetAsInteger: Longint; virtual;
    function GetAsString: string; virtual;
    function GetAsVariant: Variant; virtual;

    procedure SetAsBoolean(const Value: Boolean); virtual;
    procedure SetAsDateTime(const Value: TDateTime); virtual;
    procedure SetHint(const Value: String);
    procedure SetAsFloat(const Value: Double); virtual;
    procedure SetIdentifier(const Value: String);
    procedure SetAsInteger(const Value: Longint); virtual;
    procedure SetAsString(const Value: string); virtual;
    procedure SetAsVariant(const Value: Variant); virtual;
  protected
    function AccessError(const TypeName: string): Exception; dynamic;
    procedure SetVarValue( const Value : Variant ); virtual;
  public
    Constructor Create( const aIdentifier, aCaption : String;
                        const aDefaultValue : Variant ); virtual;

    destructor Destroy; override;

    procedure SaveToRegIni  (       aRegIni  : TRegistryIniFile;
                              const aSection : String ); virtual;
    procedure LoadFromRegIni(       aRegIni  : TRegistryIniFile;
                              const aSection : String ); virtual;

    procedure Clear; virtual;

    property DefaultValue  : Variant       read  FDefaultValue;
    property AsBoolean     : Boolean       read  GetAsBoolean
                                           write SetAsBoolean;
    property AsDateTime    : TDateTime     read  GetAsDateTime
                                           write SetAsDateTime;
    property AsFloat       : Double        read  GetAsFloat
                                           write SetAsFloat;
    property AsInteger     : Longint       read  GetAsInteger
                                           write SetAsInteger;
    property AsString      : string        read  GetAsString
                                           write SetAsString;
    property AsVariant     : Variant       read  GetAsVariant
                                           write SetAsVariant;

    property Identifier  : String          read  FIdentifier
                                           write SetIdentifier;
    property Caption     : String          read  FCaption
                                           write SetCaption;
    property Value       : Variant         read  GetAsVariant
                                           write SetAsVariant;
  end;

...

function TdvSetting.AccessError(const TypeName: string): Exception;
resourcestring
  SSettingAccessError = 'Cannot access Setting ''%s'' (%s) as type %s';
begin
  Result := Exception.CreateResFmt( @SSettingAccessError,
                                    [ Identifier, Caption, TypeName ] );
end;

procedure TdvSetting.Clear;
begin
  FValue := Null;  
end;

constructor TdvSetting.Create(const aIdentifier, aCaption: String;
  const aDefaultValue: Variant);
begin
  Create( aIdentifier, aCaption, aCaption, True, aDefaultValue );
end;

function TdvSetting.GetAsBoolean: Boolean;
begin
  raise AccessError('Boolean'); { Do not localize }
end;

function TdvSetting.GetAsDateTime: TDateTime;
begin
  raise AccessError('DateTime'); { Do not localize }
end;

function TdvSetting.GetAsFloat: Double;
begin
  raise AccessError('Float'); { Do not localize }
end;

function TdvSetting.GetAsInteger: Longint;
begin
  raise AccessError('Integer'); { Do not localize }
end;

function TdvSetting.GetAsString: string;
begin
  Result := ClassName;
end;

function TdvSetting.GetAsVariant: Variant;
begin
  raise AccessError('Variant'); { Do not localize }
end;

procedure TdvSetting.LoadFromRegIni(aRegIni: TRegistryIniFile;
  const aSection: String);
begin
  Assert( Assigned( aRegIni ), 'The aRegIni parameter should contain a TRegIni Instance' );
end;

procedure TdvSetting.SaveToRegIni(aRegIni: TRegistryIniFile;
  const aSection: String);
begin
  Assert( Assigned( aRegIni ), 'The aRegIni parameter should contain a TRegIni Instance' );
end;

procedure TdvSetting.SetAsBoolean(const Value: Boolean);
begin
  raise AccessError('Boolean'); { Do not localize }
end;

procedure TdvSetting.SetAsDateTime(const Value: TDateTime);
begin
  raise AccessError('DateTime'); { Do not localize }
end;

procedure TdvSetting.SetAsFloat(const Value: Double);
begin
  raise AccessError('Float'); { Do not localize }
end;

procedure TdvSetting.SetAsInteger(const Value: Longint);
begin
  raise AccessError('Integer'); { Do not localize }
end;

procedure TdvSetting.SetAsString(const Value: string);
begin
  raise AccessError('String'); { Do not localize }
end;

procedure TdvSetting.SetAsVariant(const Value: Variant);
begin
  if ( VarIsNull( Value ) ) then
  begin
    Clear;
  end
  else
  begin
    SetVarValue( Value );
  end;
end;

procedure TdvSetting.SetCaption(const Value: String);
begin
  FCaption := Value;
end;

procedure TdvSetting.SetHint(const Value: String);
begin
  FHint := Value;
end;

procedure TdvSetting.SetIdentifier(const Value: String);
begin
  FIdentifier := Value;
end;

procedure TdvSetting.SetVarValue(const Value: Variant);
begin
  raise AccessError('Variant'); { Do not localize }
end;

What does it do ?

Actually this piece of code doesn't do all that much. It just provides us with a base class we can now use as an ancestor for our other classes. Basically we have some ErrorHandling and a skeleton for our specific Setting classes.

Continued in Part 4

For some reason I had problems fitting everything into one single post, so I had to split it up an two parts. Go ahead and read the rest in part 4.

Well, we did get some time to think a little more about what our code is supposed to do, so we have a pretty good idea about it already. Sadly the people who originally created the code didn't really think about it. In this article we'll take a close look at how everything was programmed and we'll have a look at some of the disadvantages and how we should solve them.

The Old Code

Basically the developers though about it and they had the idea that settings should be read from the registry when the user wanted to edit them. Once the user finished changing the settings the code should store the new settings in the registry. Apparently they also had the idea to load the settings when the first form gets displayed and save them when it gets closed.

So, in the main form they had some code which looks like this :

procedure TfrmMain.FormShow(Sender: TObject);
var
  aRegistry : TRegistry;
begin
  aRegistry := TRegistry.Create;
  try
    aRegistry.OpenKey( '<THE_REGISTRY_PATH>', True);
    // FString, FInteger and FBoolean are private field declarations on
    // TfrmMain.
    FString  := aRegistry.ReadString( '<STRING_SETTING_KEY'  );
    FInteger := aRegistry.ReadInteger( '<STRING_SETTING_KEY'  );
    FBoolean := aRegistry.ReadBool( '<STRING_SETTING_KEY'  );
  finally
    aRegistry.Free;
  end;
end;

procedure TfrmMain.FormClose(Sender: TObject; var Action: TCloseAction);
var
  aRegistry : TRegistry;
begin
  aRegistry := TRegistry.Create;
  try
    // FString, FInteger and FBoolean are private field declarations on
    // TfrmMain.
    aRegistry.OpenKey( '<THE_REGISTRY_PATH>', True);
    aRegistry.WriteString( '<STRING_SETTING_KEY', FString  );
    aRegistry.WriteInteger( '<STRING_SETTING_KEY', FInteger  );
    aRegistry.WriteBool( '<STRING_SETTING_KEY', FBoolean  );
  finally
    aRegistry.Free;
  end;
end;

procedure TfrmMain.mnuEditSettingsClick(Sender: TObject);
var
  aEditSettingsForm : TfrmEditSettings;
begin
  aEditSettingsForm := TfrmEditSettings.Create( Self );
  try
    aEditSettingsForm.TheString := FString;
    aEditSettingsForm.TheInteger := FInteger;
    aEditSettingsForm.TheBoolean := FBoolean;

    if ( aEditSettingsForm.ShowModal = mrOK ) then
    begin
      FString  := aEditSettingsForm.TheString;
      FInteger := aEditSettingsForm.TheInteger;
      FBoolean := aEditSettingsForm.TheBoolean;
    end;
  finally
    FreeAndNil( aEditSettingsFrom )
  end;
end;

Will this work ?

As you can see, the code will be working. It will read the settings when the main form gets shown and store it in some private variables. When the main form gets closed, the settings will be stored. And there is even some code which will open a Edit Settings form, pass some values to it, and get some results back when the user closes the Edit Settings form by pressing the OK Button.

So what's the problem ?

Is the code executed at the right time ?

In my opinion the OnShow and OnClose events on the form arn't really the best places to execute this code. What if the settings included things related to the visual appearance of the form ? Do you want to read and change those each time this form gets shown ? Maybe you have some other settings which should get read even before the first form is shown ?

In any case you might want to read the settings or store them at different points during the execution of your application. In this example, that would require you to execute the OnShow event of the main form to load the settings. Even worst is having to rewrite or copy / paste the loading code in other locations. Believe it or not, but that's what's happening in a lot of cases.

What happens when a problem occurs while loading / saving the settingss ?

The code isn't perfect, and strange things will happen when a certain registry key doesn't exist. The code will raise an exception causing it to read or save only part of the settings and ending up with invalid settings. In our case, it would be nice if a default value was used when a certain registry key doesn't exist.

Additionally when the user opens the form to change the settings, and closes it using the OK button, the new settings are passed back to the main form, but are not stored in the registry yet. If some other part of your application now reads the settings from the registry again you might end up with different settings than the ones on your main form.

Is it really the responsibility of the main form to Load or Save settings ?

Well, in short NO ! Not at all !

What if we had to create a command line version of our application ? We might still need to read some settings from the registry, but we won't need any forms at all. What if I need to start a thread for some background processing, and need to read the settings in that thread as well ?

As you can see the Main From really shouldn't be responsible for the Loading and Saving of the settings. It can call a method to do the job, but the actual code should never be in the main form.

Another rule of mine is that a form should only contain code which has an influence on the visual aspect of the form or its components / controls. Reading settings and Writing settings doesn't have a visual inflence on the form, so it's code shouldn't be in a form. You might need to change some visual aspects based on what you read from the registry, but the actual reading itself isn't the responsibility of a form.

Is there a better alternative ?

Well, it's one thing to say that something is incorrect, but when doing so you should at least try to tell how to do it correctly. So, lets think a bit more about what we want and what we need. Generally speaking we want something to load and save application settings. It would be nice if we had some code we could use in whatever application we create in the future. It really doesn't matter how many settings we need to read, or what they are called, and what format they are the only thing we care about is that we can Load / Save / Edit and Use them. How this is done isn't our responsability but something the ApplicationSettings class should take care about.

If we need to use the settings in our applications we only need to use code which will look like this :

var
  aApplicationSettings : TApplicationSettings;
begin
  aApplicationSettings := TApplicationSettings.Create( '<OUR Registry Key>' );  
  try
    // Code used to load our settings  
    aApplicationSettings.LoadFromRegistry;
    
    // Code used to edit our settings
    if ( aApplicationSettings.EditSettings ) then    
    begin
      // Our settings got changed so we might want to do
      // something if necessary.
    end;
        
    // Code used to save our settings
    aApplicationSettings.SaveToRegistry;    
  finally
    FreeAndNil( aApplicationSettings );  
  end;
end;

Who's responsible for what ?

As you can see, our application / form or whatever doesn't really need to know how it should read the settings, it shouldn't really need to know how it is saving the settings, nor how we will display or edit the settings. The only thing it has to know is that we have Application Settings and we can use them.

Our Application Settings class on the other hand needs to know which settings the application needs, what kind of settings they are and how it should load / save each of those settings.

Are there any advantages to this approach ?

Absolutely, otherwise I wouldn't have taken the time to write all this down. Our main goal here is to use Delphi as an Object Oriented programming language, not just a RAD tool. We will be creating some classes based on our new approach, and our goal is to reuse those classes whenever necessary.

If we need to write another application tomorrow and it needs to save / load some application settings we will only have to let the system know which settings are needed, how they are called and what data type they are. All the rest of the code will simply be reused. We will spend a little more time creating the base classes and their code, but next time we need it, everything will be (almost) ready for us.

What's next ?

Well, we've been thinking and talking a lot so far, but we havn't really done any true coding yet. Maybe a few people are thinking they could have written the code in the time they read these two articles.

I'm quite sure that's possible, and I've seen it done ...

Sadly I've also been the guy who got hired 5 years after the application got written to debug the whole application in search of why something didn't work in some cases. I've also been the person who had to search through thousands of lines of code wondering why one setting never got saved or got replaced by an incorrect value. And yes, I've been that person who wished they had taken the time to think about their code before they actually started working on it :-P

Anyway, next time I'll show you how I would do it, and hopefully share some code with you.

In this series of articles I will try to show how you could easily improve your 'old' code with some simple OO techniques and some refactoring. When writing some Delphi Code I presonally have a few rules I abide by. It would probably require my a few pages to explain them all, but here are just a few to get you started with :

• Write down what your code is supposed to do
• Think before you start writing your first line of code !
• Sketch a little Class Diagram / Class Hierarchy if necessary
• If you copy / pasted the same lines of code more than twice, it's time to refactor it ! (same rule applies if you are writing the same code more than two times)
• Classes should do what they are responsible for, nothing more, nothing less
• Try to think in Objects with their responsibilities instead of thinking in procedures and processes !

To illustrate this I will be using a little example of some code which could be used in almost any application : Saving & Loading some applicaiton settings. It's a pretty simple task, but in quite a few occasions the code used to do it is ... well ... not the best example of OO development. So, lets take this example and see what we can do with our few simple rules.

A closer look at 'The Rules'

Write down what your code is supposed to do

I think pretty much every application will be storing some settings. It doens't really matter if you use a ClientDataSet, and INI File, a simple Text file or even the Windows Registry to do it. What really matters is that an application can have some settings, they user might be able to change those settings and the application will probably need to read the settings and save them.

Well that's about it really, we have written down what our code should do. Of course we might change this in the future or add some new things to it, but basically we have everything we need to get started.

An additional advantage we have now is that we have already written some very basic documentation for our code ! This is really a good way to do it, since most of the time, if you have to write the documentation once everything is finished, chances are you'll never have any documentation. Of course we still need the discipline to update our documentation if things change, but we have something to get started.

Think before you start writing your first line of code !

While writing out what your code is supposed to do, you should also get into the habit of thinking about how it's going to do it, what it will need, ... So, what our piece of code will need is :

• Some Application Settings
• Some way to load the settings
• Some way to save the settings
• Some place to save to and load from
• Some way to display the settings
• Some way to edit the settings
• Some form we will use for display / editing purposes
• Some way to use the settings in our application

In order to make it simple, we will assume that we will be storing our Application Settings in the Windows Registry for now. We could make it quite generic though and have a load / save mechanism for the Windows Registry / INI Files or any other presistance mechanism, but that's not the main focus (yet), so we'll stick with the Windows Registry.

What's next ?

Well, this is a good place to end this first article. In the next installment we'll be taking a look at some of the other rules, and maybe have a look at some 'old' code too and check how we could improve it. Meanwhile we have some time to think about what our code needs to do, and some time to sketch out a little Class Diagram as well ...

Introduction

JVC GY-HM100

From time to time I have to video tape something, which could be a special occasion or some session at a conference. For that task I've been using my Sony HDR-HC1E camcorder, which captures 1080i50 footage on HDV tapes. It's a great device and I'm really loving it, but my biggest concern now is the time I have to spend waiting while the tapes are importing into final cut pro.

So, I decided to have a look at a camera I could use which shoots HD footage on memory cards, so I could switch to a tapeless workflow instead. I noticed a JVC GY-HM100 at a Final Cut Studio session organized by Apple, and was hoping I could get my hands on one to give it a try. It took me a while to get a Camcorder for some testing, but after a while I found a company called Stake5 here in Belgium which was renting the JVC GY-HM100.

Last week I contacted the friendly folks at Stake5 and apparently they had a few of them available, so I immediately drove up there to rent one. So the review you are reading here is based on the week I spent with the JVC GY-HM100, shooting some footage, importing it into Final Cut Pro and editing it.

Supported Video Formats

The JVC GY-HM100 can record HD footage in quite a few different formats including the standard PAL and NTSC modes (50i/60i, 25p/30p) but even a 24p mode and in quite a few different resolutions (1920x1080, 1440x1080, 1280x720). Sadly it doesn't seem to record in Standard Definition format, but I have to say I only used that when I switched from SD to HD anyway. So personally I'm not really missing that feature.

Native Final Cut Workflow

The JVC GY-HM100 is sometimes advertised as the first camera which offers a full / native Final Cut Format. Since I'm using Final Cut Studio myself, I had to check if it really lived up to that promise. If I'm correct the actual format used is XDCAM EX, but you have the opportunity to capture your footage in one of the 2 different formats. So I did a few tests with the each of the formats supported by the Camcorder.

Using the Quicktime Format

This is what is supposed to give you a native Final Cut Pro format. The movies get recorded on the memory cards in a QuickTime format. I decided to give that a try, and indeed you can simply drag the QT Files from the memory card directly into Final Cut Pro and start editing.

But personally I was missing something, perhaps caused by my the habit of my tape based workflow. For that reason I'm used to the Log and Capture feature in Final Cut Pro. I used that to skim through my tapes and indicate which parts of a tape I want to import into Final Cut. While doing that I give my clips a decent name / description, ... Once I'm done with that I would batch capture the selected clips and everything would be tagged / organized properly.

So, I thought I could achieve the same thing with the Log and Transfer feature. It works in a similar way to the Log and Capture feature, except it is based on files. Sadly I couldn't use that feature to log and transfer the QT files from the device into Final Cut Pro. It didn't work when I first copied the files to a HD neither.

Drag and drop seemed to work perfectly, but I couldn't indicate which parts of specific clips I wanted to import into my project. I had to import the whole clip.

Using the MP4 Format

It is possible to set the device up so that it stores the captures in MP4 files. This file structure isn't the default file structure used by Final Cut, but it is used by a few other editing systems and thus is supposed to be more compatible.

I checked a few things on the internet before I tried that format, and noticed the folks at JVC are offering a Log and Transfer plugin for Final Cut Pro which supports the MP4 format. So now they have me hesitating ... do I want to have native Quicktime files so I can edit them directly in Final Cut Pro, or do I want the Log and Transfer feature which I could use in combination with the MP4 files.

Choices ... always choices

Audio

The GY-HM100 comes with 2 XLR inputs

By default the JVC GY-HM100 seems to have a lot more audio features than my current camcorder. By default it comes with a microphone jack and mini headphone output and a built-in microphone. Nothing special here, but what's quite interesting is that it also comes with a shotgun type microphone which you can connect to one of the two XLR inputs on the handle which you can attach to the camcorder.

Still Images

The only thing I will say here is that the JVC GY-HM100 can capture 2 megapixel still photos if you need them. Most of the time I'm carrying my DSLR around so I probably wouldn't be using that feature a lot. But hey, it is quite useful if you don't have any other still camera with you.

Memory Cards

The camcorder records to SDHC Cards, which are commonly used in other devices as well. These SDHC cards are actually rather cheap compared to some of the other systems / memory cards used in professional Camcorders. You can actually put 2 of those cards in your camcorder and choose on which card you want to record. The camcorder can be configured so it automatically switches from Card A to Card B when the card is full.

I recorded some material at 1080p25 and I could fit about 55 minutes of footage on a single 16 Gb SDHC card. With 2 cards in the device I could record almost 2 hours of footage. Using 2 32 GB cards you could probably record 3,5 hours of footage in 1080p25 format.

Manual Controls

Controls on the back are sometimes hard to use

My Sony HDR-HC1E offers quite a lot of manual controls, so I was looking for similar things in the JVC GY-HM100 and it offered almost the same set of manual controls. Of course you can use the Auto Mode and let the device configure itself, but in some situations you want to have manual control over things like Focus, Aperture, Shutter Speed, Exposure and especially White Balance.

The JVC GY-HM100 offers all of that and even some more. I have to say that in some occasions using the dial to modify the Aperture / Shutter Speed / Exposure is a little cumbersome. The dial is a bit small and placed right next to the battery making it difficult to use, especially in cold weather when using gloves.

There is one thing I'm really missing on the JVC GY-HM100 though ... On my Sony HDR-HC1E, I can turn on an option which would display a grid of 9 blocks on the LCD display. A great tool to compose your image using the rule of thirds, but I happened to be using that a lot to see if I was holding the camera horizontally. I have been looking through the JVC GY-HM100 menus, but sadly I couldn't find that option.

Ease of use

3 user configurable buttons

Well, the JVC GY-HM100 is a bit larger than my Sony HDR-HC1E, but if you detach the handle with the shotgun microphone it still is a quite portable camcorder. The LCD and Viewfinder are similar to what you will find on similar devices and I didn't have any problems with them.

The Menu system is quite intuitive, and easy to use. I found that everything was well organized and most things were self explanatory. When I took the camera out for the first few test shots the weather here in Belgium was actually pretty cold, so I was wearing gloves. That made it a bit more difficult to use the joystick to navigate through the menus and select what I needed, but everything worked fine without the gloves.

There are 3 buttons on the camcorder which you can configure to your own preferences. 2 of them are easily accessible at the front of the device (close to the focus ring) and the third one is accessible when you open the LCD display.

Conclusion

Well, if you're a Final Cut user and are looking for a descent prosumer level camera which offers a Tapeless HD based workflow, then the JVC GY-HM100 might be the camera you are looking for. It offers great features and wonderful footage. It's quite easy to use and actually offers a few really neat features. The media it used (SDHC) is quite affordable which even improves it's usability.

Pro's

• Great Video quality
• Many different video modes to choose from
• Native FCP workflow (if you're a FCP user of course)
• Lots of manual control
• 2 XLR Inputs !!! So you can use pro level microphones with your camcorder
• Focus assist which will color everything in focus in a specific color allowing you to easily focus
• Tapeless workflow with 2 SDHC memory cards
• Light, Portable and easy to use
• Shotgun microphone included

Cons

• Missing the Grid I have on my Sony HDR-HC1E. So used to it to see if I'm holding the camera horizontally or to get a better composition
• Battery Life ! Think the default battery only lasted for about 80 minutes. Maybe there is an option to buy more powerful batteries (I did that for my Sony as well)
• Only a single ring for both Focus and Zoom
• Controls on the back are too close to the battery making them harder to use

Now that we know what Social Media is, it is important to think a few minutes about how you could use Social Media to make your product, service or brand better. It doesn't really matter if you have a big company with a lot of products or services, or if you are a small company only providing a single product or service. What is important is that Social Media is here, everyone is using it, and you could use Social Media to get better at what you do.

Monitor what people are saying about your Product, Service or Brand

It is a good idea to start monitoring what people are saying about your product or service. Wether that's on Twitter, Facebook, Blogs or in Podcasts, you should be able to keep an eye on what your customers are saying.

Positive Feedback is always nice, negative feedback is priceless !

I know a lot of you (myself included) look for positive feedback on the things you do. It's always great to get compliments and see people say you're doing a great job. But personally I pay special attention to people giving negative feedback. The main reason here is that I can use that information to learn from my mistakes, and make sure that I do a better job next time.

Feedback has become personal again

Since Social Media is allowing everyone to express their opinions (good or bad), it can become a big source of information. Before the era of Social Media, people would express their opinions about a product or a service, but chances are that by the time that feedback reaches you, you have no idea where it originally came from. That makes it pretty hard to work with that feedback.

With Social Media everything is becoming personal again. If you notice some feedback on Facebook or Twitter, it is now pretty easy to determine who actually gave that feedback. You can even contact that person directly and ask for more information !

Use the negative feedback to get more information from your customers

A few days ago, I upgraded a software product I bought and started to notice some problems with the new version of the product. I created a few tweets about it, asking if other users had the same problems. Apparently the company was monitoring the Tweets about their product and they noticed my feedback.

It didn't take them long to contact me personally through Twitter and ask me what the actual problem was. A few tweets later we shared information and our email addresses in order to communicate. They asked me additional questions and even asked me if I could prepare some sample files for them to analyze, hoping they could locate the problem and possibly solve it in a next version.

Final Word

As you can see, it might take some practicing and some time to actually start using Social Media to improve your product, service or brand. But you should take a moment to monitor what people are saying about you. While monitoring, chances are you will also encounter some negative feedback.

Your main goal now isn't to tell them to shut up or make them delete that feedback, but instead use that negative feedback to get more information. Set up a personal communication with the person in question and try to see how you can help them fix their problems or issues.

You might even want to get into Social Media yourselves and create a Twitter of Facebook account for your product, service or brand in order for your customers to target their feedback directly to you.

One thing is certain, no matter how you actually use Social Media, it can be an immense source of information which should allow you to learn from previous mistakes and improve your product, service or brand !

Social Media is hot, everyone talks about it, and everyone is using that phrase lately. But there are still a lot of misunderstandings as to what Social Media actually is, what it's advantages are, what the pitfalls are and how you could use Social Media to your own advantage. Quite a lot of people seem to thing that Twitter is Social Media, or Facebook is Social Media. Those two examples are actually only part of the equation, and are often referred to as Social Networks.

What exactly is Social Media then ?

Well, in short Social Media is content created by real people, people with faces, opinions and influences. It is actually a term used to describe various activities which integrate technology, discussions, communication and lots more. But the most important thing might be that it's content created by users just like you and me.

Social Media encourages Participation

Social Media is a new form of media (at least when compared to the more traditional forms of media like Newspapers, TV, ...) which encourages participation. Everyone who is interested in the topic is encouraged to contribute and give feedback. This is actually a big difference with the traditional forms of media. In the traditional media communication goes in one direction, which is from the Media to the end user. Social Media opens new opportunities because it allows a bi-directional form of communication. For example, I'm writing this article, and if it would appear in a newspaper or magazine it would be rather static. Giving feedback isn't all that easy using the traditional media.

Instead of using traditional media, this article is posted on a Blog. The blog is open to anyone, allowing any user who reads this article to give feedback, share his opinions and even correct me if I'm saying something wrong.

It's all about Conversation and Communication

Social Media really depends in interaction between people. Wether the topic is Personal or Professional it is always meant to be a bi-directional communication. I could create some content on a Product or Service I'm offering, but if I'm unable to get feedback on it, it's actually pretty worthless to me. Using Social Media I can actually interact with others, hear their opinions about my Product or Service. What's even better is that I can actually use that feedback to improve my Product or Service, and that is actually something which is often forgotten.

It's also about building a Community

Using Social Media it is actually quite easy to quickly build a community which shares a common interest. I could easily be a New Media or Social Media evangelist, but if I'm talking to myself constantly, then what's the point ? Whatever content you are creating, there are people out there who share that interest. And if your content is informative to them, they will probably start to give feedback. After a while you will have a community of like-minded people. If you start to use that feedback you will probably even get better at creating the content and might even gain the thrust of your community.

So, what is Social Media (in 140 characters or less)

At some point someone asked me if I could describe what Social Media is in a single Tweet, which is actually in 140 characters or less. Well, that's actually a bit hard to do, but here is my attempt :

"Social Media is a form of New/Online Media which encourages participation, conversation, openness and a community aspect."

— Stefaan Lesage - Devia

This will probably not cover everything, but I couldn't describe it better in such a small amount of characters.

Forms of Social Media

Now that we have an idea about what Social Media is, and what it is all about, lets have a look at the different forms of Social Media. There are actually a few different kinds of social media, and this list is by no means complete. Due to constant innovation and changes, this list might even get obsolete pretty soon. Still, lets try to give a few examples :

Social Networks

Social Networks are sites that allow users to connect with friends, colleagues and share content with them. There are plenty of those, but the biggest ones are Facebook, LinkedIn, MySpace, Ning, Netlog, ... Each of these Social Network sites might have it's own targeted audience.

Blogs

Blogs are a form of online journals in which the different posts or entries appear in a chronological order. Most of the time they appeal to a smaller niche of users than the Social Networks, although some of the blogs are actually pretty big. Blogs can have one or more authors who create the different entries, but in most cases anyone can post comments and feedback on those articles.

Podcasts

People often tend to forget Podcasts, but they do form a part of what's called Social Media. Podcasts offer similar content to blogs, most of the time in audio or video format. The content is made available to the end user be form of a subscription. In many cases Podcasts also have a website or blog associated to them.

Forums

We probably all know what forums are. They are a form of Social Media, since they actually encourage online discussions. Most of the forums are created around specific areas of interests. Forums actually existed long before anyone used the term "social media", but they are an inherent part of it.

Content Communities

Quite similar to Social Networks, the Content Communities focus around a specific type of content. This could be photos (Flickr), bookmaked links (delicious), videos (YouTube, Vimeo, Viddler, ...). Content Communities allow you to share that specific type of content with other users, and quite often are open for feedback on specific content.

Microblogging

Microblogging is often referred to as a Social Network in which all users can create very small 'blog' posts. These small pieces of content (often called updates or status updates) are available online and offline (quite often there is a mobile phone client). The best example here is Twitter of course.

Final Word

Well, this is of course my view on what Social Media actually is, and what it is about. If you do not agree with my view or have anything to add, please feel free to use the Comments section below this article. After all, we are trying to create Social Media and start a conversation with the Community :-)

Blogworld & New Media Expo

It took me a while before I actually decided to go to Las Vegas for the Blogworld and New Media Expo. After all it is quite a long and expensive trip from Belgium. But now that I have been there, I have to admit that the cost of the whole trip was nothing compared to the information and knowledge I gathered during the many sessions. I learned quite a lot of new things from people with a lot more knowledge about New and Social Media than myself.

If you would ask me if it was worth it's money, I would definitely answer YES !

If you would ask me if I will be attending next year ... well if I can fit it into my schedule, then surely YES !

What I expected from Blogworld & New Media Expo

Before I actually left for Blogworld & New Media Expo, I had some expectations, and the most important ones were to learn and to network. If I could succeed in both then the trip would have been worth it to me. I was hoping to learn a lot of new things about Podcasting and everything related to Podcasting.

What did I get at Blogworld & New Media Expo

The tracks and sessions at Blogworld & New Media Expo

The first day of the Expo sadly didn't have any Podcasting related sessions at all, but pretty soon I noticed there were a lot of other great sessions that day. There was a whole track about using Social Media for non-profit organizations which was actually very interesting.

That track was not only interesting for the non-profit organizations but were also packed with great information for general use. At one point someone mentioned that it isn't the number of people you know which will allow you to raise the most money. You actually need to put out regular updates, progress reports, keep people engaged and get them wrapped up in the Cause. I believe that most of this is actually true for anything you wish to do with social media, even with Podcasting.

Networking Opportunities

The conference was actually a great opportunity to meet new people, and meet up with the faces behind some podcasts I have been listening to. I met up with a lot of people from the Mac Roundtable Crew and a few others. Some of the podcasters and other people I met were Allison Sheridan (Nosillacast), Victor Cajaio (Typical Mac User and Typical Shutterbug Podcast), Don McAllister (ScreenCastsOnline), John Chambers (One Minute Tip), George Starcher, Dave Hamilton, John F Braun, Jean MacDonald (Smile on my mac), Chuck Joiner (MacVoices), David Sparks (MacSparky), Israel Hyman (IzzyVideo) and Dr. Talli van Sunder (Being Healthy for Busy People). I really hope I didn't forget anyone in this list.

What did I miss at Blogworld & New Media Expo

The Blogworld Expo Website

I don't know why, but I had the impression, during the months leading up to the event, that there were a few things missing. Even till a week before Blogworld & New Media Expo I had that impression. Most of the Sessions on the Calendar and the Website didn't have any detailed description at all. Even when checking the Schedule and the details for the sessions I attended, all of them say 'Session description coming soon'. Without details on the different sessions it was actually hard to choose, and I guess a few people (including me) might have missed a few very interesting sessions.

Famous in the US might be unknown elsewhere

In some of the Keynote sessions people were brought on to the stage which should be famous, but I never heard of them. For example, The Bloggess might be famous and well known in the US, but I had never heard of her before. She was funny, but she gave me the impression she had too much of something before she showed up on stage. That whole last keynote was quite funny, but in my humble opinion it didn't add anything of value to Blogworld & New Media Expo.

The Expo floor felt a bit strange to me

Well, I did expect a lot more audio and video equipment vendors on the exhibit floor, sadly only Shure was there with some interesting goodies. During the many sessions I attended, I noticed that there was a great interest in Video for blogging and podcasting, but yet not Video Equipment Vendors were actually present. Maybe something to look at for next year ?

What will the future bring for Blogworld & New Media Expo

Well, I hope the people behind this convention will learn from the small problems and mistakes they made. After all, we are all human and we do all make mistakes, but we need to learn from those. I'm quite sure that next years Blogworld & New Media Expo will be even bigger and better, and if I can squeeze it into my schedule I will surely be part of it. And if there is any additional need for speakers to fill the Podcasting track, I might even be interested to help with that.

Goal

Before leaving for Podcamp Barcelona I had a specific goal in mind. I didn't want to convince everyone in the room to start using Podcasts in the Classroom, although that would have been nice. My goal was to share my opinion with them, tell them why I think podcasting is a great educational tool and show them a few examples of existing podcasts. My only goal was to inspire them, get them interested at looking into the subject of Educational Podcasting and make them think about how it could be used in an educational environment.

Result

I have uploaded the Presentation to Slideshare and included it in this post.

Apparently the session has been video taped as well, and is currently being processed. Once the video is available somewhere, I'll make sure to post a link to it on the website.

Other Presentations

Of course I wasn't the only one presenting at Podcamp Barcelona, and there were plenty of other interesting sessions. Thanks to the simultaneous translation of Spanish / Catalan presentations into English, I was able to understand what they were saying, and actually learned quite a few new things.

Steve Lawson : "Amplified'09"

I met Steve Lawson on Friday. He's a great guy with fantastic ideas and in my opintion an excellent 'communication starter'. At podcamp he was telling us about Amplified '09. The concept is easier to understand, than it is to explain it. They are actually Amplifying events and bringing different networks together. He explained it to me as a network of networks. He talked about how Social Media can be used to gather ideas, start inter company projects and share knowledge.

David Allen : Creating a Succesful Podcast

David is the guys behind the Mac20Q (Mac 20 Questions) podcast, and a few other podcasts as well. His goal is to show us the tools he is using to create his podcasts and how he uses Twitter and other Social Media to connect with people he can then interview for one of his podcasts.

He was also talking about 'protecting your brand', and tells us we should register on all Social Media related websites (Twitter, Facebook, Tumblr, Ping.Fm, ...) using our brand namen, even if we don't plan on using it. That way you protect your brand and register it's name, prohibiting others to use it in your place.

Catavino : Wine and Social Media

Catavino is a website with information on Spanish and Portuguese wines and has a worldwide audience. They started as one of the first Wine related blog, and are active in a small niche. Meanwhile they are the most comprehensive and educational website covering Spanish and Portuguese wine, iberian food, culture and travel. One of the things they organize is wine tastings, and that is exactly what they did at Podcamp Barcelona as well.

Dolores Reig : Free

Dolores did a great speach on changes in Education. She talked about some of the problems we currently have with education being and even suggested a few ways in which we could solve those. She presented some new business models which could be used to solve a few problems (copyright for example) and also discussed some options and tools for free education.

Gregor Gimmy : Sclipo

Sclipo is actually one of those Online Education related websites and is somehow a mix of Slideshare, Flickr, Youtube, ... The whole website is designed to help people learn and tech better using things like a Webcam-based classroom for live teaching & Webinars. Gregor gave us a quick demo of Sclipo. I have been using Sclipo to upload some video tutorials to it, but I didn't know it had all those additional features. I will have to check it out.

Delphine Lebédel : Woman & Mozilla

Delphine told us a bit about the History of the Mozilla project and the different types of team members and how they collaborate together. She also presented a new project, which is called "Women in Mozilla". As we all know the IT world consists mostly of men, and in Open Source communities the percentage of female participants is really low. The goal of the Women & Mozilla project is to promote the implication of woman in the FLOSS world in general, and particularly in the Mozilla Project. I have to say, that I'm all for these kind of projects, so if you are interested in it, please have a look on their website and help Delphine spread the word.

Podcamp Barcelona 2009 was a success

For me, Podcamp Barcelona was a success. I have been getting great feedback on my presentation, learned a lot of new and interesting people, and even learned some new things as well. I would like to thank everyone who helped organising this event, especially Chris and Anna, the translators, technicians, presenters and public. Thanks to all of you Podcamp Barcelona 2009 was really worth it !

CocoaHeads is a group devoted to discussion of Apple Computer’s Cocoa Framework for programming on MacOS X (including theiPhone). During monthly meetings, members present on their projects and offer tutorials on various programming topics.

What about CocoaHeads Belgium ?

CocoaHeads Belgium is the first Chapter of CocoaHeads in Belgium and our Founding Meeting will take place on monday 28 september 2009 starting at 19:00 in the offices of IBBT (Zuiderpoort Office Park, Gaston Crommenlaan 8, 9050 Gent-Ledeberg, Belgium).

This first meeting wil be an informal meeting in which attendees will have the opportunity to meet with other Cocoa and CocoaTouch enthousiasts from Belgium.

The goal of this meeting is to have a brainstorm session with the attendees. This session will give everyone the opportunity to help us shape the future of CocoaHeads Belgium and make sure CocoaHeads Belgium will become THE event for Cocoa developers and by Cocoa developers.

Registration

The meeting is free for everyone interested in Mac & iPhone development. We kindly ask you to register for the event at Eventbrite. Spaces are limited, so if you want to attend, register as soon as possible.

Additional information can be found on the CocoaHeads Belgium website.