John Kaster’s Diamondback talk

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.

Leave a Reply

Your email address will not be published. Required fields are marked *