John Kaster's Diamondback Talk

John Kaster's Diamondback talk (From Joe White's Blog)

Covering John Kaster's preconference tutorial on what's new in Diamondback (that which we dare not call Delphi 9).

This talk was yesterday afternoon, but there wasn't enough convergence of wall power and working wireless to post it until now. So, here goes.

Before he even started the session, I caught a glimpse of Diamondback running on his machine. The first thing I noticed was that there are three tabs at the bottom of the editor window: "Code", "Design", and "History". Very intriguing.

His handouts were hefty. 65 sheets, 128 printed sides front and back. The first 19 pages (not counting the cover page) were just an outline.

He did not go into detail on all of this material. He had to rush a fair bit to cover what he did. (Pity, 'cause there was some really good stuff. I wish they'd split the not-really-Delphi stuff, like ASP.NET and ECO, into a separate presentation to give him more time.)

Once again, I had two and a half pages of notes before the break. Once again, I only added another half page after the break (when he was covering ASP.NET and ECO). Good stuff, though.

Still no official word on timelines, not even "you'll hear about it at the opening session", so I assume that (a) it's still a ways off and (b) management has sent out a decree that Thou Shalt Not Discuss The Release. It's too bad. If they were selling Diamondback today, there's no question in my mind that we would upgrade everyone in a heartbeat.

Officially confirmed: Diamondback will support Delphi for Win32, Delphi for .NET, and C#, all within the same IDE.

You'll even be able to put Delphi and C# projects into the same project group. I know that Sam, Brian, and I will all very much appreciate this!

He showed videos from folks who couldn't make it but had demoed their features ahead of time. These videos will hit BDN around the time Diamondback ships.
IDE look & feel improvements: Object Inspector, tool palette
Delphi Direct goes away. Instead, the BDN news feed appears on Welcome page.

You'll be able to add your own feeds
Even John K turned Delphi Direct off!

Sweet! The Locals view will allow you to change which stack frame you're inspecting!
The "An exception has occurred" debugger dialog will have a "Don't show this exception class again" checkbox
"Log call stack" breakpoint action
Color-coded event log
Built-in IDE QualityCentral reporting
The CPU view will show the source, the IL, and the x86 code! (Holy cow, that'll be cool. Visual Studio can show the source and the x86, but can't show the IL!)
Side note: VCL for Win32 does not do Unicode, and there are no plans to add it.

For people who need Unicode VCL in Win32, he suggested the free TNT controls, and said they have the Danny Thorpe Seal of Approval.

Wavy red underlines for compiler errors; hints showing the error message
Refactoring (whoo!)

Rename
Extract Method

Knows when to, and when not to, use var parameters
Don't know whether it can do out parameters or function returns

Extract Resource String

Picks a default name for the resource string
If that name already exists, reuses the existing resourcestring

Sync Edit (select a block, hit a button, and it underlines all the duplicated words; click on one and start typing, and it syncs with all the others within the block)
Find unit or namespace
Declare Field
Declare Variable

Right-click on an identifier, select "Declare Variable"
Smart — guesses a reasonable data type

Shows a preview of what's going to be changed, and doesn't apply until you say go
All of these work in Delphi for Win32 and Delphi for .NET
All except Extract Resource String work for C#
Unsurfaced Refactoring API, so there will probably be more refactorings in later versions

Find References, Find Local References

Not by name. If there are two different TFoo classes in two different units, this will find only references to the one you selelcted. (Based on the same metadata as refactoring)
Doesn't go through the compiler, so it's very fast

Tool palette improvements

Not just components anymore
File New stuff is now in the tool palette
Incremental search: start typing, filters the list
Can drag categories and items around to reorder them, to optimize the incremental search for what you use most
Ctrl+Alt+P focuses the Tool Palette, so you often don't even need the mouse

Compiler can export XML doc comments
Hover over a symbol: shows XML doc comment in a hint menu, with a stylesheet (HTML formatted, hyperlinks). Unlike Visual Studio, this only works if you have the compiler export the XML doc file.
Demand loading of Win32 design-time packages (Allen blogged about the consequences of this decision, but didn't say what the reason was)
History view

Every time you save, it rolls a new backup file
You can specify how many levels of backup to keep
Diff between versions
There will be some level of integration with StarTeam here (but not in the build he was running)

D8 Enterprise already ships with a StarTeam Standard license
Diamondback will have solid StarTeam integration

Browse & open directly from repository
File renames are tracked on server

New Open Tools APIs, including a syntax-highlighting API
Function inlining

Several caveats
"[C]ompiling the other unit at the same time as compiling the call site (build all) is a different situation than inlining a function that was loaded from a precompiled .dcu" (though it's not clear what that means)
The compiler can refuse to inline a function
Looks like this is mainly for the functions in Windows.pas. It's not clear how useful it will be for user code.

Forward declared record types (maybe .NET only; need to ask Danny)
Multi-unit namespaces

Last segment of unit name is just disambiguation for the compiler, not for .NET namespaces
File A.B.C.pas used to go into namespace A.B.C, but will now go to namespace A.B
New convention for globals: global Foo in A.B.C.pas is now A.B.Units.C.Foo
He didn't go into much detail, but I'm guessing that if your package has a default namespace of Foo.Bar, and your filenames are A.pas, B.pas, and C.pas (not multipart names), then everything will probably export directly into the Foo.Bar namespace.

for..in: (see also: Danny's blog post)

You will still have to declare the loop variable in your 'var' section.
Many BCL classes will support for..in (TList, TStrings, TFields, etc.)

Not in Diamondback/Win32 (but maybe in future Win32 compilers):

Nested types
Records with methods
Operator overloading
Custom attributes
Generics
Multicast events

Still no way to put VCL controls on WinForms
Come to Meet the Team, Monday night. Each dev will show off their favorite features.