ITDevCon 2011 Time Table

Yes, it is a bit late, but this year has been really difficult to choose between all the speeches proposals arrived from all over the world.
The new Delphi XE2 version (and the RAD Studio XE2 Suite too) are really full of new cool features and many of the best delphi developers want to show what can be done in Delphi XE2. Great situation!

However, also this year, there will be many talks and many speakers. For the first time there will be 2 plenary sessions with more than one speaker in the main TObject hall. During these sessions all the attendants will be in the same hall and I’m sure that there will be very interesting Q&A time at the end of the sessions.
As usual there will be english and italian speeches. In every time frame you will find a suitable talk for your language.

This year we are glad to have DavidI as a conference speaker. Thanks to be with us David!

As you can see from the time table, there will be many topics, but if you are particulary interested in Firemonkey, LiveBindings, DataSnap and Mobile, you will find a specific sets of speeches about these topics.

In particular:

  • DavidI and Pavel Glowacky will show all the cool stuff available in Delphi XE2
  • Marco Cantù will held an interesting session about Firemonkey development
  • Bruno Fierens will held a 2 parts session about Firemonkey cross-platform component development.
  • I’ll hold 2 sessions about LiveBindings and how to use them with the most popular Data Access Design Patterns
  • Debora Mizzoni (web) and Luca Giacalone (android) will talk about mobile development with RadPHP
  • Salvatore Sparacino will show how to use the datasnap mobile connectors to develop a real-world app
  • and many others on many others topics

This year we’ll have also a “Conference App” very similar to the Google I/O one. With this app you will be able to:

  • Read the time table
  • Set you preferred speeches
  • Read infos about the speakers
  • Comment on speeches
  • Share you comments about itdevcon on facebook and twitter
  • Read infos about our sponsors

This app has been developed using Delphi and the datasnap mobile connectors (for the backend) and an Android device for the frontend. ASAP the app will be published on the Android Market. Here’s some screen shots from the “ITDevCon2011” android app.

The home screen
The time table with all the speeches infos. The starred ones are your preferred speeches.
Speaker's details

The principal developer of this app (Salvatore Sparacino) will explain all parts (datasnap, the connectors, and the android development) in a specific talk. Are you interested in mobile development using Delphi as backend? If yes, you cannot miss his talk!

The time table is available here.
The complete speakers list is available here.

You can register for the event here.

There are interesting discounts for groups, students and for whom will buy RAD Studio XE2 in these days. If you are interested, contact directly our sales office at dir_comm at bittime.it.

See you in Verona!

ITDevCon 2011 – Call4Papers

Dear potential ITDevCon speaker,

I’m building the agenda for next ITDevCon 2011 that will be held in late october in Verona, the same location of the past year. Dates will be announced ASAP.

The call for papers are officially open right now, so if you want to propose some speeches, I’ll be glad to see it.

As usual, for the Call4Paper I need:

  • Title (for every talk)
  • Abstract (for every talk)
  • Difficulty level (for every talk. Difficulty level is a scale from 1 to 3 with the following mean: introduction, intermediate, advanced)
  • Speaker’s photo
  • Speaker’s profile

I’m looking forward to your proposal. The call4papers ends at June 30th, 2011.

Send your proposal to this email address.

Proposals will be evaluated and the speakers will be contacted ASAP.

This year topics will be the following:

TOPICS
– Delphi Fundamentals
– Delphi Advanced
– Design Pattern (GoF, Enterprise, Integration)
– Refactory
– Domain-Driven Design
– Agile
– Optimization
– Metaprogramming
– ORM
– Rad PHP
– Open Source Delphi Libraries
– Continuous Integration
– OOD/OOP
– Developers Tools
– Middleware
– Components
– IDE extensions
– Native Delphi
– Beyond Delphi on Windows
– Web development with Native Delphi
– WebServices
– SOA and ROA
– HW integration
– Games

Target audience
– Software architects
– Software developers
– Project managers
– IT managers
– Trainers

The conference web site is http://www.itdevcon.it (still under construction).

Thanks and see you at ITDevCon 2011.

P.S. Have you a suggestion for this ITDevCon edition? Let me know your improvement proposal.

ITDevCon 2010

Last Friday ended the second edition of ITDevCon, the European Conference on Delphi and its related technologies.
ITDevCon This year was even bigger.
There have been more present, more sponsors, more speakers, more topics and a lot of people with the desire to learn new things and improve their every day work.
In addition to a large group of Italian and European speakers, we had speakers from all over the world. From the coast of the U.S. Ovest to Russia. The participants who came from all over Europe. The most intrepid of them even came from Australia to follow the Mobile Boost on Android and the 2-day conference. Congratulations!
A special thanks goes to all the speakers who participated and the sponsors who have contributed their support to make this conference a major event for the European community Delphi.
I hope that the content and the organization is liked to you at least half of how much it is liked to me.
We are organizing slides, videos and examples for each speech to put it all on-line available to participants at the conference as soon as possible. You will receive an email informing you of how to download all the material available.
In the coming days, on the conference website (www.itdevcon.it) we will post all the pictures we have done in these three days. If you have any photos that you want to see published, send them to me, we’ll publish it on the official website.

Many speakers already blogged about the conference:

Paweł Głowacki
http://blogs.embarcadero.com/pawelglowacki/2010/11/22/39140

Marco Cantù
http://blog.marcocantu.com/blog/itdevcon2010_report.html

José León Serna
http://www.joseleon.es/2010/11/22/itdevcon-2010-conclusions/

Bruno Fierens
http://www.tmssoftware.com/site/blog.asp?post=185

Primoz Gabrijelcic
http://www.thedelphigeek.com/2010/11/itdevcon-2010.html

And now, Daniele Teti 🙂

If you want to see the tweet about the conference, you can go here.

I thank again all those who have spoken and all those who have attended to ITDevCon.
See you next year.

— Daniele

My Speeches at ITDevCon 2009 (Italy, Verona)

Tomorrow I travel to Verona to the ITDevCon the Italian Delphi Conference.
The conference will be at 11-12 november, and will be REALLY great!

You can see the time table here.

At this conference I will speak about:

  • Marshal e UnMarshal in Delphi 2010
  • Enterprise Data Access patterns in Delphi
  • Delphi e i messaging systems… ZeroMQ + AMQP e ActiveMQ + STOMP

My speeches will be in italian language only.

See you in Verona!

Custom Marshalling/UnMarshalling in Delphi 2010

Introduction
Some days ago, Embarcadero has presented the new version of RAD Studio, 2010.
The are many new features, but you can find in a lot places around the web, so
I won’t repeat them here.

One of the things widely requested from all Delphi programmers all over the world over the past few years, including myself, is
certainly a new and more powerful RTTI.

The new system of RTTI has finally arrived, and pave the way for a large number of applications.
One area that has benefited from the new RTTI is for sure the marshaled objects.

Marshaling is defined as follows:

“In computer science, marshalling (similar to serialization) is the process of
transforming the memory representation of an object to a data format suitable for
storage or transmission. It is typically used when data must be moved between
different parts of a computer program or from one program to another.
The opposite, or reverse, of marshalling is called unmarshalling (demarshalling) (similar to deserialization).”
–WikiPedia

In Delphi 2010 the process of serialization and deserialization is handled respectively by a Marshaller and an Unmarshaller.

The built-in format for the serialization of any Delphi object is JSON.
There are 2 main classes responsible for serializing objects into JSON, both present in the unit DBXJSONReflect:
– TJSONMarshal
– TJSONUnMarshal

Let’s say you have an object defined as follow:

type
  TKid = class
    FirstName: String;
    LastName: String;
    Age: Integer;
  end;

To serialize and deserialize an instance of TKid it requires the following steps:

var
  Mar: TJSONMarshal;  //Serializer
  UnMar: TJSONUnMarshal;  //UnSerializer
  Kid: TKid;  //The Object to serialize
  SerializedKid: TJSONObject;  //Serialized for of object
begin
  Mar := TJSONMarshal.Create(TJSONConverter.Create);
  try
    Kid := TKid.Create;
    try
      Kid.FirstName := 'Daniele';
      Kid.LastName := 'Teti';      
      Kid.Age := 29;      
      SerializedKid := Mar.Marshal(Kid) as TJSONObject;
    finally
      FreeAndNil(Kid);
    end;
  finally
    Mar.Free;
  end;
  //Output the JSON version of the Kid object
  WriteLn(SerializedKid.ToString);   
  // UnMarshalling Kid
  UnMar := TJSONUnMarshal.Create;
  try
    Kid := UnMar.UnMarshal(SerializedKid) as TKid;
    try
      //now kid is the same as before marshalling
      Assert(Kid.FirstName = 'Daniele');
      Assert(Kid.LastName = 'Teti');
      Assert(Kid.Age = 29);
    finally
      Kid.Free;
    end;
  finally
    UnMar.Free;
  end;
end;

Simple, isn’t it?
To access the JSON string that is our object, we must call the method ToString.
The JSON representation of this object SerializedKid can be saved to file,
sent to a remote server, used by a Web page from a web service, stored on a database or sent into space (!!!).
The Delphi application re-read the JSON string, you can recreate the object as it was at the time of serialization.
But anyone with a JSON parser can still read the data in our object, even non Delphi client.
These are the advantages of having used an open format and standard.

So far the simple part …
How serialize a field differently from the default?

Suppose we add the date of birth to our TKid:

type
  TKid = class
    FirstName: String;
    LastName: String;
    Age: Integer;
    BornDate: TDateTime;
  end; 

Serialize a TDateTime, localized and that I have in JSON string is a float, because for Delphi TDateTime is a decimal number.
If I read the data from another program Delphi, no problem, but if I wanted to read a script in JavaScript? or. NET? or Ruby?
Then I use a format “DATA” to understand, even for these languages.
The new engine provides the serialization too.
Is needed, however, to tell the Marshaller and UnMarsheller how to represent and reconstruct a particular
object field by two statements like the following:

//marshaller
Marshaller.RegisterConverter(TKid, 'BornDate', 
  function(Data: TObject; Field: string): string
  var
    ctx: TRttiContext; date : TDateTime;
  begin
    date := ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsType<TDateTime>;
    Result := FormatDateTime('yyyy-mm-dd hh:nn:ss', date);
  end);
  
//UnMarshaller
UnMarshaller.RegisterReverter(TKid, 'BornDate', 
  procedure(Data: TObject; Field: string; Arg: string)
  var
    ctx: TRttiContext;
    datetime:TDateTime;
  begin
    datetime := EncodeDateTime(StrToInt(Copy(Arg, 1, 4)), 
                               StrToInt(Copy(Arg, 6, 2)), 
                               StrToInt(Copy(Arg, 9, 2)), 
                               StrToInt(Copy(Arg, 12, 2)), 
                               StrToInt(Copy(Arg, 15, 2)), 
                               StrToInt(Copy(Arg, 18, 2)), 0);
    ctx.GetType(Data.ClassType).GetField(Field).SetValue(Data, datetime);
  end);

The anonymous method is called when the marshaller serializes the field ‘BornDate’ is called “Converter” while Unmarshaller anonymous method that calls when he has to reconstruct the object from the JSON string is the “Reverter”.
Thus serializing a TKid assure you that my object is readable both by Delphi from another language without loss of information.

But what happens when I have to serialize a complex type?

Suppose we extend TKid this:

type
  TTeenager = class(TKid)
    Phones: TStringList;
    constructor Create; virtual;
    destructor Destroy; virtual;
  end; 

We must define a Converter and a Reverter for the TStringList class.
We can do it this way:

var
  Marshaller: TJSONMarshal;
  UnMarshaller: TJSONUnMarshal;
  Teenager: TTeenager;
  Value, JSONTeenager: TJSONObject;
begin
  Marshaller := TJSONMarshal.Create(TJSONConverter.Create);
  try
    Marshaller.RegisterConverter(TTeenager, 'BornDate', 
      function(Data: TObject; Field: string): string
      var
        ctx: TRttiContext; date : TDateTime;
      begin
        date := ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsType<TDateTime>;
        Result := FormatDateTime('yyyy-mm-dd hh:nn:ss', date);
      end);
      
    Marshaller.RegisterConverter(TStringList, function(Data: TObject): TListOfStrings
                                              var
                                                i, count: integer;
                                              begin
                                                count := TStringList(Data).count;
                                                SetLength(Result, count);
                                                for i := 0 to count - 1 do
                                                  Result[i] := TStringList(Data)[i];
                                              end);  //TStringList Converter 
    Teenager := TTeenager.CreateAndInitialize;
    try
      Value := Marshaller.Marshal(Teenager) as TJSONObject;
    finally
      Teenager.Free;
    end;
  finally
    Marshaller.Free;
  end;
  // UnMarshalling Teenager
  UnMarshaller := TJSONUnMarshal.Create;
  try
    UnMarshaller.RegisterReverter(TTeenager, 'BornDate', 
      procedure(Data: TObject; Field: string; Arg: string)
      var
        ctx: TRttiContext;
        datetime: TDateTime;
      begin
        datetime := EncodeDateTime(StrToInt(Copy(Arg, 1, 4)), 
                                   StrToInt(Copy(Arg, 6, 2)), 
                                   StrToInt(Copy(Arg, 9, 2)), 
                                   StrToInt(Copy(Arg, 12, 2)), 
                                   StrToInt(Copy(Arg, 15, 2)), 
                                   StrToInt(Copy(Arg, 18, 2)), 0);
        ctx.GetType(Data.ClassType).GetField(Field).SetValue(Data, datetime);
      end);
    UnMarshaller.RegisterReverter(TStringList, function(Data: TListOfStrings): TObject
                                               var
                                                 StrList: TStringList;
                                                 Str: string;
                                               begin
                                                 StrList := TStringList.Create;
                                                 for Str in Data do
                                                   StrList.Add(Str);
                                                 Result := StrList;
                                               end);  //TStringList Reverter

    Teenager := UnMarshaller.Unmarshal(Value) as TTeenager;
    try
      Assert('Daniele' = Teenager.FirstName);
      Assert('Teti' = Teenager.LastName);
      Assert(29 = Teenager.Age);
      Assert(EncodeDate(1979, 11, 4) = Teenager.BornDate);
      Assert(3 = Teenager.Phones.Count);
      Assert('NUMBER01'=Teenager.Phones[0]);
      Assert('NUMBER02'=Teenager.Phones[1]);
      Assert('NUMBER03'=Teenager.Phones[2]);
    finally
      Teenager.Free;
    end;
  finally
    UnMarshaller.Free;
  end;
end;

There are different types of Converter and Reverter.
In the the DBXJSONReflect there are 8 types of converters:

  //Convert a field in an object array
  TObjectsConverter = reference to function(Data: TObject; Field: String): TListOfObjects;
  //Convert a field in a strings array
  TStringsConverter = reference to function(Data: TObject; Field: string): TListOfStrings;

  //Convert a type in an objects array
  TTypeObjectsConverter = reference to function(Data: TObject): TListOfObjects;
  //Convert a type in a strings array  
  TTypeStringsConverter = reference to function(Data: TObject): TListOfStrings;

  //Convert a field in an object
  TObjectConverter = reference to function(Data: TObject; Field: String): TObject;
  //Convert a field in a string  
  TStringConverter = reference to function(Data: TObject; Field: string): string;

  //Convert specified type in an object
  TTypeObjectConverter = reference to function(Data: TObject): TObject;
  //Convert specified type in a string  
  TTypeStringConverter = reference to function(Data: TObject): string;

Each of them deals with a particular conversion object representation in the final serialization, in our case we will use them to convert to JSON.

Also in the DBXJSONReflect unit are defined many “Reverter” dealing with retrieving
the serialized version of the data and use it to reconstruct the object previously serialized.
Because they are complementary to the Converter, I will not copy them here.

As a final example, we derive from TProgrammer by TTeenager adding a list of Laptops in the properties.

Is therefore necessary to introduce a new pair of Converter / Reverter.
In this example I have defined all the converter and reverter in another unit in
order to have more readable code:

type
  TLaptop = class
    Model: String;
    Price: Currency;
    constructor Create(AModel: String; APrice: Currency);
  end;
  TLaptops = TObjectList<TLaptop>;
  TProgrammer = class(TTeenager)
    Laptops: TLaptops;
    constructor Create; override;
    destructor Destroy; override;
    class function CreateAndInitialize: TProgrammer;
  end;
// Implementation code...
var
  Marshaller: TJSONMarshal;
  UnMarshaller: TJSONUnMarshal;
  Programmer: TProgrammer;
  Value, JSONProgrammer: TJSONObject;
begin
  Marshaller := TJSONMarshal.Create(TJSONConverter.Create);
  try
    Marshaller.RegisterConverter(TProgrammer, 'BornDate', ISODateTimeConverter);
    Marshaller.RegisterConverter(TStringList, StringListConverter);
    Marshaller.RegisterConverter(TProgrammer, 'Laptops', LaptopListConverter);
    Programmer := TProgrammer.CreateAndInitialize;
    try
      Value := Marshaller.Marshal(Programmer) as TJSONObject;
    finally
      Programmer.Free;
    end;

    // UnMarshalling Programmer
    UnMarshaller := TJSONUnMarshal.Create;
    try
      UnMarshaller.RegisterReverter(TProgrammer, 'BornDate', ISODateTimeReverter);
      UnMarshaller.RegisterReverter(TStringList, StringListReverter);
      UnMarshaller.RegisterReverter(TProgrammer, 'Laptops', LaptopListReverter);

      Programmer := UnMarshaller.Unmarshal(Value) as TProgrammer;
      try
        Assert('Daniele' = Programmer.FirstName);
        Assert('Teti' = Programmer.LastName);
        Assert(29 = Programmer.Age);
        Assert(EncodeDate(1979, 11, 4) = Programmer.BornDate);
        Assert(3 = Programmer.Phones.Count);
        Assert('NUMBER01' = Programmer.Phones[0]);
        Assert('NUMBER02' = Programmer.Phones[1]);
        Assert('NUMBER03' = Programmer.Phones[2]);
        Assert('HP Presario C700' = Programmer.Laptops[0].Model);
        Assert(1000 = Programmer.Laptops[0].Price);
        Assert('Toshiba Satellite Pro' = Programmer.Laptops[1].Model);
        Assert(800 = Programmer.Laptops[1].Price);
        Assert('IBM Travelmate 500' = Programmer.Laptops[2].Model);
        Assert(1300 = Programmer.Laptops[2].Price);
      finally
        Programmer.Free;
      end;
    finally
      UnMarshaller.Free;
    end;
  finally
    Marshaller.Free;
  end;
end;


Unit CustomConverter.pas contains all needed Converters/Reverts as anon methods.

unit CustomConverter;

interface

uses
  DBXJSONReflect,
  MyObjects; //Needed by converter and reverter for TLaptops

var
  ISODateTimeConverter: TStringConverter;
  ISODateTimeReverter: TStringReverter;

  StringListConverter: TTypeStringsConverter;
  StringListReverter: TTypeStringsReverter;

  LaptopListConverter: TObjectsConverter;
  LaptopListReverter: TObjectsReverter;

implementation

uses
  SysUtils, RTTI, DateUtils, Classes;

initialization

LaptopListConverter := function(Data: TObject; Field: String): TListOfObjects
var
  Laptops: TLaptops;
  i: integer;
begin
  Laptops := TProgrammer(Data).Laptops;
  SetLength(Result, Laptops.Count);
  if Laptops.Count > 0 then
    for I := 0 to Laptops.Count - 1 do
      Result[I] := Laptops[i];
end;


LaptopListReverter := procedure(Data: TObject; Field: String; Args: TListOfObjects)
var
  obj: TObject;
  Laptops: TLaptops;
  Laptop: TLaptop;
  i: integer;
begin
  Laptops := TProgrammer(Data).Laptops;
  Laptops.Clear;
  for obj in Args do
  begin
    laptop := obj as TLaptop;
    Laptops.Add(TLaptop.Create(laptop.Model, laptop.Price));
  end;
end;

StringListConverter := function(Data: TObject): TListOfStrings
var
  i, count: integer;
begin
  count := TStringList(Data).count;
  SetLength(Result, count);
  for i := 0 to count - 1 do
    Result[i] := TStringList(Data)[i];
end;


StringListReverter := function(Data: TListOfStrings): TObject
var
  StrList: TStringList;
  Str: string;
begin
  StrList := TStringList.Create;
  for Str in Data do
    StrList.Add(Str);
  Result := StrList;
end;

ISODateTimeConverter := function(Data: TObject; Field: string): string
var
  ctx: TRttiContext; date : TDateTime;
begin
  date := ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsType<TDateTime>;
  Result := FormatDateTime('yyyy-mm-dd hh:nn:ss', date);
end;

ISODateTimeReverter := procedure(Data: TObject; Field: string; Arg: string)
var
  ctx: TRttiContext;
  datetime :
  TDateTime;
begin
  datetime := EncodeDateTime(StrToInt(Copy(Arg, 1, 4)), StrToInt(Copy(Arg, 6, 2)), StrToInt(Copy(Arg, 9, 2)), StrToInt
      (Copy(Arg, 12, 2)), StrToInt(Copy(Arg, 15, 2)), StrToInt(Copy(Arg, 18, 2)), 0);
  ctx.GetType(Data.ClassType).GetField(Field).SetValue(Data, datetime);
end;

end.

Last hint…
Every serialization/unserialization process can create “warnings”.
Those warnings are collected into the “Warnings” property of the Ser/UnSer Object.

Conclusions
In this post I tried to introduce the basics of the new serialization engine in Delphi 2010.
During the next ITDevCon to be held in Italy next November 11.12, I’ll have a talk in which I will extensively talk about serialization and RTTI.
All interested smart developers are invited 🙂

ITALIAN P.S.
Se qualche programmatore italiano volesse avere la versione in italiano di questo post può lasciare un commento e vedrò di accontentarlo 🙂

You can find the DUnit project Source Code