The conference is organized by S&S Media and supported by Embarcadero/CodeGear.

We have got all the top speakers, including Cary Jensson, Marco Cantu and Ray Konopka.

Many (most?) members of Delphi R&D team (including Barry Kelly – “The Delphi Compiler”) will be at the conference and there will be of course "Meet the Team" sessions.

All Sessions are online and registration is now open. The speakers list includes all those who already submitted their bio and photo. For a complete list of speakers please refer to the list of sessions for now.

If you register before April 10th, 2009, then you can take advantage of the Early Bird rebates.

When : May 13 – 16, 2009
Where: San Jose, CA, USA

More information: www.delphilive.com

S&S Media is a book/magazine publisher and software conference organizer. S&S is well known in the Delphi community for their Delphi focused "EKON" conferences and "Entwickler" magazines.

For comments, questions or concerns you may use the contact form on the DelphiLive web site, or just leave a comment here.

As an Advisory Board member I am proud to post this official pre-announcement for the next, long awaited physical Delphi conference.

Where: San Jose, CA, USA
When: May 13th – 16th 2009
Who: All Delphi developers, let it be Delphi Win 32, Delphi Prism or Delphi for PHP ones.

We will try to get all the known top speakers, from the US and Overseas to make this event absolutely rocking. The conference will be organized by Software & Support Verlag, supported by CodeGear / Embarcadero. San Jose was chosen as location as it is close to CodeGear’s HQ, so that CodeGear staff can show up easily.

Attendees

For now, block this event in your calendar if you are interested. We will keep the price affordable – details will be posted asap.

To register, please go to the DelphiLive 2009 Website – which will go online in the next two weeks. We will send announcement emails through CodeGear’s Developer Network as soon as registration is open. Make sure you are signed up at CodeGear Developer Network and CDN emails are not blocked by your spam filters.

Speakers

If you want to present sessions at Delphi Live 2009, then please stay tuned for the official Call For Papers, which will be made public in the next 2 days or so.

Topics

We will cover from basics to advanced topics all around Delphi. The final topic list will be made available as soon as the call for papers is closed.

Following is a draft of tracks:

• Architecture / Design
• OOP
• Database
• IDE, Tools & Components
• Core Development
• Basics / Fundamentals
• Native Delphi
• Delphi Prism
• Delphi & .NET
• Delphi & Web
• Delphi & PHP
• Delphi & Ruby on Rails

If you have suggestions for specific topics you would like to be covered (and which you do not want to present yourself), then feel free to post these suggestions as comments to this blog. The same goes for speakers which you would definitely like to see in San Jose.

TEmployee = class(TPerson)
private
FHoursPerWeek: Double;
FWeeklyRate: Double;
FHourlyRate: Double;
procedure SetHourlyRate(const Value: Double);
procedure SetHoursPerWeek(const Value: Double);
function GetWeeklyRate: Double;
public
property HourlyRate: Double read FHourlyRate write SetHourlyRate;
property HoursPerWeek: Double read FHoursPerWeek write SetHoursPerWeek;
property WeeklyRate: Double read GetWeeklyRate;
end;

...

{ TEmployee }

function TEmployee.GetWeeklyRate: Double;
begin
Result := HourlyRate * HoursPerWeek;
end;

procedure TEmployee.SetHourlyRate(const Value: Double);
begin
FHourlyRate := Value;
end;

procedure TEmployee.SetHoursPerWeek(const Value: Double);
begin
FHoursPerWeek := Value;
end;

In the example above “HourlyRate” is what an employee get’s paid per hour. This value can be read and set. “WeeklyRate” is a read/only calculated value, which depends on “HourlyRate” and “HoursPerWeek”.

This all looks fine and we know how to deal with that since years. And it works the same way in Delphi Prism.

But sometimes, when you design a new class, do you always follow the “property-hides-field” pattern? Even if Delphi makes life easy with “Ctrl-Shift-C”, the code may look pretty much bloated, esp. if you have standard properties, not doing anything special. So you might just use “simple” Fields where possible. This is bad design of course, as if you need to change to a “real” property later, because you need to calculate something in a get or set method, you would have to change your classes signature, which may break compatibility …

Delphi Prism introduces two new language features to Pascal, which may prevent code from bloating and actually helps readability.

Implicit Fields

Implicit fields are fields which are created by the compiler automatically for properties which do not have any read or write accessors.

This is how the example would look like using implicit fields:

TEmployee = class(TPerson)
private
FWeeklyRate: Double;
function GetWeeklyRate: Double;
public
property HourlyRate: Double;
property HoursPerWeek: Double;
property WeeklyRate: Double read GetWeeklyRate;
end;
implementation

{ TEmployee }
function TEmployee.GetWeeklyRate: Double;
begin
Result := HourlyRate * HoursPerWeek;
end;

So this already look much less bloated. Implicit fields are not an invention of Delphi Prism though, but they were introduced with C# 3.0 Implicit Fields exist in Prism since 2004. They were introduced to C# 3.0 just a moment later, in 2008 , and they are called Auto-Implemented Properties here. The beauty of Pascal gets apparent though, once you compare Prism’s syntax with its C# equivalent:

class TEmployee
{
public Double HourlyRate {get; set;}
public Double HoursPerWeek {get; set;}

...
}

In Pascal there is no need to write these “stub” get and set calls.

Technically, it’s important to notice that Prism automatically creates a “get” and “set” method, plus a hidden private field for these properties. These hidden fields cannot be accessed in the classes code,  just use the Property itself everywhere. If you are not convinced that there are really hidden fields, then lets have a look at the IL code behind that (extracted using Red Gate’s Reflector):

.method public hidebysig specialname instance void set_HoursPerWeek(float64 'value') cil managed
{
.maxstack 3
L_0000: ldarg.0
L_0001: ldarg.1
L_0002: stfld float64 WindowsApplication5.TEmployee::@p_HoursPerWeek
L_0007: ret
}

The field gets obviously hidden by using “@” in it’s name which is not valid for Pascal, thus cannot be accessed. In C#, they are using brackets in the hidden private field name for the same purpose:

<HoursPerWeek>k__BackingField

Inline Expressions

With inline expressions you can make the code look even nicer. And best of all, to my knowledge there is no C# equivalent

Inline expressions may be used directly after the “read” keyword. This may drastically improve the readability of your code. Compare the final code example with the one at the very top!

TEmployee = class(TPerson)
public
property HourlyRate: Double;
property HoursPerWeek: Double;
property WeeklyRate: Double read HourlyRate * HoursPerWeek;
end;

Yes, this the complete TEmployee definition. No further implementation needed. Just 6 Lines, compared to the initial roughly 25 ones!

The Delphi Prism Wiki has an entry about “Class Properties”, which explains a few more details. (The “Implicit Fields” feature is a bit “hidden” though)

This is a “Customer” class definition with a manual mapping to a “Customers” table on a SQL Server 2005:

type
[Table(Name := 'Customers')]
Customer = class(Object)
private
protected
public
[Column(IsPrimaryKey := true)]
property CustNo:Double;
[Column]
property Name: String;
[Column]
property Country: String;
end;

This is the actual LINQ to SQL code that relies on the class definition above:

method MainForm.button2_Click(sender: System.Object; e: System.EventArgs);
var
LCustomers: Table<Customer>;
LDBMain: DataContext;
LConnectionString:String;
begin
LConnectionString := 'Data Source=.\SQLEXPRESS;Initial Catalog=DBDEMOS;Integrated Security=True';
LDBMain := new DataContext(LConnectionString);
LCustomers := LDBMain.GetTable<Customer>();
var USCustomers := from Customer in LCustomers where Customer.Country = 'US' select Customer;

for each Customer in USCustomers do begin
listBox1.Items.Add(Customer.Name);
end;
end;

Interesting to note is that Prism has a very nice name scope mechanism. Even though “Customer” is a Class name, it is also used as local variable in the LINQ and FOR constructs. I am not saying that this is a good practice though

Technically, both “Customer” variables are different variables – which is quite important to understand.

The full demo source can be downloaded here: [download#2].

The good news is, RemObjects implemented all required compiler support! Excellent!

See the simple example below:

method MainForm.button1_Click(sender: System.Object; e: System.EventArgs);
var
lCustomer: Customer;
lCustomers : List<Customer>;
begin
lCustomers := new List<Customer>;

lCustomer := new Customer;
lCustomer.Name := 'Olaf';
lCustomer.Country := 'Germany';
lCustomers.Add(lCustomer);

lCustomer := new Customer();
lCustomer.Name := 'Jim';
lCustomer.Country := 'USA';
lCustomers.Add(lCustomer);

//Inline declaration using type inference
var GermanCustomers :=
from Customer in LCustomers
where Customer.Country.Equals('Germany');

//Has nothing to do with LINQ, but that's type inference too:
for Customer in GermanCustomers do begin
listBox1.Items.Add(Customer.Name);
end;
end;

Interesting to notice is how the variables “GermanCustomers” and “Customers” are declared. They are both declared inline using type inference – which is one of the important enhancements over Delphi Win32.

See the Prism Wiki for details on LINQ.

DevExpress is a component set and productivity plugin vendor who serves the VCL and .NET market. DXCore is a base library which is heavily used by their CodeRush and Refactor products.

To finally enable Sync Editing after installing DXCore you need to copy one file manually. Just follow the steps in this  Prism Wiki article.

Delphi Prism

Delphi  Prism is basically a plugin for Visual Studio, which delivers the Pascal Language plus some exciting extra features to Microsoft’s .NET development platform.

Get a trial version from CodeGear’s Code Central. Delphi Prism is part of RAD Studio 2009,  the ISO (1.4 GB!) offered for download on that page contains Prism only though.

Prism has to be activated by a license key. You can request a 14 day trial license on the same page and/or use a purchased RAD Studio 2009 license key. In other words the ISO contains the full product.

The Prism product page does not yet have a “purchase” link, but the marketing department is currently working on getting an announcement e-mail blown out. I guess that the purchase link will be activated while that happens. As the ISO contains the full product, you can switch from trial to full after the 14 days, just by entering a new license key.

Technical Information

Prism is not an upgrade of what you may know as Delphi.NET from RAD Studio 2007 or earlier. Prism is a complete new tool. It has been developed by a partner of CodeGear’s, RemObjects and comes as the solution for .NET and Mono in RAD Studio 2009. It completely “integrates” with the .NET framework. It does not bring any “Delphi Win32” dependencies. This means all executables/assemblies you will create with Prism will be “pure” .NET (or Mono) ones. No more P/invoke weirdness.

Porting Delphi Applications

The good news are: Prism Pascal is very compatible to Delphi Native Pascal. There are a couple of differences, which are well documented.

The bad news are: There is no VCL on Delphi Prism. In other words you can port business code more or less easily, but you have to re-implement your GUI code. After all I don’t think that’s  too bad though. You have all .NET possibilities instead. System.Windows.Forms, WPF, Silverlight …

If you want to dig into the technical details, then have a look at the Delphi Prism Wiki. As Delphi user you might want to start with Delphi Prism syntax compared with Delphi Win32 syntax.

More information to come (including German Prism Workshop in Darmstadt) …

Apparently, the new Delphi 2009 TStringBuilder class has not got much attention yet, so I’ll give a short recap here.

Under .NET there is a StringBuilder class since the very beginning. This is because in .NET Strings are immutable, which means that once the content of a string instance is set, it is fixed. It cannot be changed anymore. “Quasi modifying” operations require new instances to be created and the old ones to be discarded:

s := s + ‘a’  means “create a new string instance and initialize it with the old content of s plus an ‘a’, then throw the old instance s pointed to into the garbage collector”

Lot of pressure on the memory management system that is.

Thus StringBuilder was invented. The core idea is to prepare some buffer and let all operations work on that buffer, so that you don’t need to recreate instances all the time. The buffer is still managed, and all are happy.

The question is now: “why do we need a TStringBuilder class in Delphi/Win32, and if it is a “real” class (i.e. not just a highly optimized type in System.pas), could it be really fast?”

Well, it appears to be fast, look at this code (test environment: Core 2 Duo, 2GHz):

// approx 2.2 sec ~45M operations/sec
LStart := GetTickCount;
for i := 0 to 100000000 do begin
SB.Append(' ');
end;
LStop := GetTickCount;
Writeln('StringBuilder: ', LStop - LStart);

// approx 3.8 sec ~ 26M operations/sec
s:='';
LStart := GetTickCount;
for i := 0 to 100000000 do begin
s := s + ' ';
end;
LStop := GetTickCount;
Writeln('String: ', LStop - LStart);

// approx 3.5 sec ~ 28M operations/sec
a:='';
LStart := GetTickCount;
for i := 0 to 100000000 do begin
a := a + ' ';
end;
LStop := GetTickCount;
Writeln('AnsiString: ', LStop - LStart);

So obviously TStringBuilder is useful for certain operations, as its significantly faster than String. As expected AnsiString is faster than String, but its still slower than TStringBuilder.

So this leaves to investigate when TStringBuilder has advantages, besides in this fairly artificial case. To be continued …

For those of you being curious how the next Delphi for .NET might look like:

CodeGear just “inofficially” announced a Delphi Prism Beta which is basically something like Delphi in Visual Studio. Nick Hodges showed off some early information at SDN in the Netherlands.

Allen Bauer also comments on these, maybe surprising news. So far it looks like in the future there will be two Delphi products, one for Win 32 Development (in the IDE we all know), and an other VisualStudio based IDE for .NET development.

Update: For WordPress there is a SyntaxHighlighter Plus plugin, which is also based on the code below.  I’ve updated my posts here on the new WP based blog system to use that plugin.

I just found Alex Gorbatchev’s excellent SyntaxHighlighter on Google Code. It’s JavaScript based and makes it very easy to pretty-print your source code examples. It comes with modules for:

• C#
• C++
• CSS
• Delphi
• Java
• Javascript
• PHP
• Python
• Ruby
• SQL
• VisualBAsic
• XML

It’s completely modular, so if you need Delphi only, then you don’t have to load all other modules. Usage is very easy, just add the following to your HTML template that drives your blog or source code pages:

<script src="/js/shCore.js" type="text/javascript"></script>
<script src="/js/shBrushDelphi.js" type="text/javascript"></script>
<script type="text/javascript"></script>

shCore.js is about 13KB, the language modules and clipboard.swf are just two KB in average. If you need Delphi and C# then just add shCSharp.js to the list above. To show a piece of source code you insert the raw source inside a <pre></pre> tag pair. The actual formatting will be done by SyntaxHighlighter.

<pre class="delphi">
var
  s: string;
begin
  s := 'Hello World';
end;
</pre>