Borland Conference 2004 Blogs

Acknowledgement

This is the compilation of all Borcon 2004 blogs that I have read regularly during Borcon 2004. All articles in this compilation belong to the authors. Before putting all these articles together, I obtained permission from all authors. Please contact the authors regarding their articles.

Following are the authors who granted permission to use their articles, listed alphabetically:

Serge Dosyukov - http://borcon2004.blogspot.com/
Euan Garden - http://sqljunkies.com/WebLog/euang/
Nick Hodges - http://www.lemanix.com/nick/
Robert Love - http://peakxml.com/
Jim McKeeth - http://www.bsdg.org/
Dave Nottage - http://www.teamb.com/davenottage/
Craig Stuntz - http://blogs.teamb.com/craigstuntz
Joe White - http://excastle.com/blog/

I receive no benefit or compensation from any authors, from Borland Corporation or from any other parties for this compilation. This compilation is given to the Borland users. Thank you to all bloggers for their excellent reports. If you find any mistakes, please let me know.

Table of Contents

1. Preconference.

1.1. Tutorial Sessions - day 1 - extended and corrected.

1.2. Get Ready for Microsoft .NET Framework 2.0.

1.2.1. Live from Danny's Talk.

1.2.2. Delphi Syntax for Generics.

1.2.3. 64 Bit Changes for the CLR.

1.2.4. Danny's .NET 2.0 talk: Part One.

1.2.5. Danny's .NET 2.0 talk: Part Two.

1.3. John Kaster's Diamondback talk.

1.4. Fetch my Lino.. and drive me to ASP.NET.

1.5. ASP.NET 2.0 overview session.

1.6. Tutorial Sessions - day 2.

1.7. Test Driven Development with Charlie Calvert.

2. Borcon Sunday Sessions and Events.

2.1. Sunday at Borcon.

2.2. Borcon Day 1 - Sunday.

2.3. Opening Session.

2.3.1. BorCon 2004 is opened - short.

2.3.2. Opening Ceremony.

2.3.3. Unleash the Power - From the BorCon Opening Session.

2.3.4. Opening session and opening keynote.

2.3.5. WHOO! *Happy dance*.

2.4. Borcon Opening Keynote.

2.4.1. Live Blogging from the Borland Keynote.

2.4.2. Welcome Keynote and Reception.

2.4.3. Live from the Opening Keynote.

2.4.4. Diamondback at Opening Keynote.

3. Borcon Monday Sessions and Events.

3.1. Borland Keynote.

3.1.1. Monday's morning keynote session.

3.1.2. Monday Morning Session.

3.1.3. Diamondback and JBuilder 2005.

3.1.4. Kylix community project.

3.1.5. Unit Testing in Diamondback at Monday General Session.

3.2. What's New in Diamondback.

3.2.1. What's new in Diamondback - Allen Bauer.

3.2.2. What's New in Delphi with Allen Bauer.

3.2.3. Allen Bauer's "What's New in Diamondback" session.

3.3. More New IB 7.5 Performance Monitoring Features.

3.4. Microsoft Keynote - from Borcon.

3.5. Delphi 8 and SQL Server Yukon.

3.6. Borcon Day 2 - Monday.

3.7. NDataStore.

3.7.1. New Borland Product: nDataStore.

3.7.2. NDataStore.

3.7.3. NDataStore.

3.8. Refactoring with Jim Cooper.

3.9. What's New in the Delphi Compiler.

3.9.1. What is new in the Delphi Compiler - Danny Thorpe.

3.9.2. Danny's "What's New in the Diamondback Compiler" session.

3.9.3. What *wasn't* in Danny's Diamondback session.

3.10. DiamondBack Preview.

3.10.1. DiamondBack preview - tonight session.

3.10.2. Live From the Diamondback Preview!

3.10.3. Diamondback Preview Session.

3.10.4. Diamondback Debugging.

4. Borcon Tuesday Sessions and Events.

4.1. RemObjects at BorCon.

4.2. Overview of InterBase 7.5.

4.3. Borcon Day 3 - Tuesday.

4.4. Creating Custom ASP.NET Components with Nick Hodges.

5. Borcon Closing Sessions.

5.1. BorCon 2004 closing session.

6. Resources.

1. Preconference

1.1. Tutorial Sessions - day 1 - extended and corrected

Serge Dosyukov

From a variety of sessions I .ve choose two:

• Microsoft .net Framework Security by Steve Teixeira
• XML in Microsoft .Net Framework by Robert Love

Bellow is a little about first

I think it was a great session. Yes, there is not enough time to cover .Net security in 4 hours, but Steve did great presentation.

He covered main aspects of incorporating security context into your application.
Next topics were included:

• set a security for your application code -at design time
• assemblies security settings . signing, security certificates, &
• cryptography in your applications
• security in ASP.Net applications
• ASP.Net authorization

What is good about all such sessions, it gives you an idea where to look and what to expect. It gives you a starting point from which you can elaborate and come with a solution you need.

Note You might be surprised, but you will see a lot of Diamondback (Delphi 9) or Delphi 8 during a sessions which are in any way related to .Net and require some code samples. Almost all demos are done within them . you can see C# or ASP.Net code, Delphi.Win32 or Delphi.Net. I think this is showing a big effort of Borland in promoting a new version of Delphi or Delphi in general. I will encourage you to look at these products today and as soon as it (Delphi 9) will be available for evaluation.

Second session by Robert. Great session! Tutorial provided a basic coverage of main elements on how XML is used throughout MS .Net Framework. All samples was done using Delphi for .Net (Delphi 2005 or Delphi 9.0, I really do not know what it will be at the end, I like 2005 better). Robert cover main aspects of use of XML from application: reading and writing from/in XML document, validation, and transformation. What I personally found handy . it is how any Delphi class can be easily serialized via XML by using XMLSerializer. It is easy and fully customizable. Great addition for Delphi component streaming.

posted by Serge at 2:39 PM

1.2. Get Ready for Microsoft .NET Framework 2.0

1.2.1. Live from Danny's Talk

Nick Hodges

Okay, folks, I am sitting here in a conference room with a couple of my TeamB mates. Danny Thorpe is standing on the podium getting ready to give a four hour tutorial on the topic of .Get Ready for Microsoft.Net 2.0 .. I think in the interest of being on the cutting edge, I am going to give a shot at live blogging his talk. How does that sound? We'll see how it goes, eh? I have a personal rule: If Danny's talking, I listen. And now you can virtually .listen . as well. Keep hitting refresh, as I'll be updating this all morning.

Things will be getting underway here in about 15 minutes.

Danny is talking on the new Dotnet framework, .Whidbey .. He specifically says he's not talking to the MS marketing slides, but to the technical end of things. (Not a surprise, as Danny doesn't suffer marketing well, I don't think....)

Danny is pointing out that Avalon will be available on XP eventually, as it has been decoupled from the release of Longhorn. Interesting.

Danny points out how there is a blurry line between what C# is and can do, and what the CLR/Platform does. As a Delphi developer, he's far more interested in the platform.

Driving Factors for 2.0

Improve Security -- MS did a complete audit of their codebase to improve security of the core infrastructure.
Improve .Host Control . -- i.e. improve the ability to host CLR-based assemblies.
Improve Performance and memory use.

Danny points out that 2.0 development is really being driven by Yukon/SQL Server -- that the needs of what they want to do with Yukon is what is driving the development of 2.0.

CLR Architectural Changes

Generic Types are probably the most significant change.
Large increases in CLR Host capabilities
64-bit platforms will be released only on the 2.0 platform, including Intel Itanium II, AMD64
Improved Compact Framework support -- less .Hackish . particularly for the design environments. Danny says that Borland is .very keen . to support the CF in Delphi, and they are continuing to work with MS to work this issue out.

C# Language Changes

Generic Types, Partial classes, Anonymous Methods, yield iterators

Danny points out again that there should be a clear difference between CLR features and C# features, but that the line is alway blurred, especially in the press. He is showing us an example of C# generics, and discusses how they can actually improve codegen and code savings. Danny says Delphi will implement the 2.0 generic model. Methods will be able to declare generic types as well. Danny says that the Delphi syntax will look almost the same as the C# syntax. Generics will allow things like generic TList implementations to manage specific types and reduce the amount of typecasting needed to manage lists of pointers, etc. This will be really cool I think.

Anonymous methods: I confess I can't understand exactly what this is. It seems like a different kind of polymorphism, where you can declare a method that will get .filled in later . sort of like an abstract method.

Partial Classes: You can split a class in half, with multiple source files implementing parts of classes. You'd then separate out machine generated code from user generated code. (Think of, say, the ugly .InitializeComponents . call that does what the DFM in Delphi does. That code would end up in a different file that would be .hidden . or whatever. Code folding apparently isn't good enough here. ;-) In other words, your event handler code would be in one file, and the changes made in the Winforms designer would get put into another file. Another good example is, say, an ActiveX generated unit that you might modify, and then lose your modifications when the file is regenerated. (Editors Note: This is the kind of thing I hate -- this is a lot of work just because C# has this crappy model and no DFM files.)

This also means that ASP.NET will have a sort of .code-beside . model, instead of .code-behind .. Partial classes will be used to augment your source. The ASP.NET framework will actually have total access to your classes, because they are declared as partial classes.

New Iterators: The ability to .yield . back in the middle of iteration to present data to the caller. Think about the ability to iterate over a dataset, with the iterator being able to return each row for modification.

VB.NET Language Changes

They will be able to access, but not define, generic types
Partial classes
Operator Overloading
XML DocGen
Edit and Continue Debugging (Yuk! Is it just me, or is this a catastrophically bad idea?)

I'm not going to bother talking about the C++ Language changes. I find .Managed C++ . to be one of the ugliest, silliest ideas in all of the programming world, so let's just pretend that it never happened, okay?

Danny is now entering into the Will DeWitt/Dennis Landi portion of the talk, and discussing the 64-bit end of the 2.0 framework.

• The JIT compiler will compile IL code to native 64 bit instructions for AMD64 and Itanium-2, but not Itanium-1
• Need to remember that SizeOf(Integer) <> SizeOf(Pointer)
• Can PInvoke into unmanaged Win64 code
• Will have IL Binary portability (i.e. you can take a binary from machine to machine, and 32-bit to 64-bit)

Danny's pointing out that Delphi will support the CF framework and the 2.0 Framework as soon as possible, but that they are in beta, and thus a real moving target. He points out that with the 1.0 framework, the metadata streaming was totally changed late in the beta, and something like that causes big problems for folks like Borland. They plan to do a Delphi release that will synchronize with the 2.0 framework when the 2.0 framework is released. Danny expects that to be .summerish . in 2005.

He's now talking about how generics might be implemented in the Win32 compiler. He thinks that they might be able to do it -- they have a plan. They'll implement it in .Net first, and then give it a look. It will probably be a sub-set of the .Net version, and not a complete implementation.

ASP.NET 2.0

• Declarative Databinding -- now you have to write code to do databinding. 2.0 will have declarative databinding. It's data-driven, but still some code.
• Provider Model -- drop a module in to do a specific service. For example, a login provider. There's canned stuff in the framework, but you can define your own. Another example -- credit card management, catalog management
• Web Parts -- Portal/personalization functionality. You can move stuff around, skin the colors, etc.
• Master Pages -- easily define a Master Page and a Theme for your application. Easily separate/decouple this from code. Themes will tie into the CSS stuff, allowing you to easily manage that for the user, or have the user manage it himself.

Okay, back from the break:

Yukon/SQL Server

• It will host CLR code in process, allowing you to build assemblies to do the storedproc thing instead of SQL
• Why? Gives Yukon lots of security and control over data access
• Won't even look at code that doesn't PEVerify
• You can define your own complex field types in your assemblies.
• Want to add flexibility and dynamic functionality and while at the same time providing security.
• Yukon is practically an operating system unto itself. Takes over CLR Memory allocation, CLR Exception Handling, and the CLR Security Model, Thread scheduling
• Yukon will inspect all managed code to ensure it can be executed. If you don't pass, you don't load.
• Will abort your code .at the slightest provocation .
• Yukon prefers that your code not have any global, static information/variables to prevent having interprocess communications. It prefers object instances and stack variables
• Yukon will require the 2.0 framework, and won't do 1.1 at all.
• This is definitely a move by MS to move into the Enterprise space. They definitely are targeting Orcacle here
• The Yukon team is pushing the CLR folks to be more scalable, secure etc. Danny notes that Yukon is having a real positive effect on the CLR

Compatibility with 1.1?

• Theory is that .Net will get rid of DLL hell. But this hasn't really been tested until there is a totally binary incompatible version of the framework out there. That's coming, though
• There should be very few source code incompatibilites. The 2.0 framework should have all the calls from 1.1. There may be side effects, however.
• 1.x and 2.0 should sit side-by-side on your machine.
• You might be able to use an app.config file to .float . a 1.1 binary up to bind against 2.0, but .caveat emptor .
• You can right now tinker around with the 2.0 platform if you rebuild the Delphi RTL to work agains the 2.0 framework if you rebuild the Delphi RTL using the command line compiler. The Delphi compiler can only compile against a given platform.

What does this all mean for you?

• Danny recommends that if you are starting a project today, you should work against 1.1, but keep an eye on 2.0. Obviously something like generics is going to change the way that you do things. Some of the interoperability rules change, for example. New stuff will change the way you debug, probably. Think about debugging a partial class, for example
• This is a 2.0 release, not a 1.0 release. .We are out of diapers .. This has gone through a lot of code review
• There will be application versioning concerns. You need to realize it is out there, and may affect your 1.1 apps, even though it isn't supposed to. ;-)
• Danny points out that 2.0 means a lot more to MS than it does to us. Yukon using 2.0 in a big way. It's MS's push into the enterprise space. Good for developers, because CLR gets stronger, more scalable. .Microsoft is betting the farm on 2.0 . says Danny.

posted on Saturday, September 11, 2004 9:27 AM

1.2.2. Delphi Syntax for Generics

Robert Love

I am sitting in Danny Thorpe's session on CLR 2.0, and did not want to wait to post this little tidbit. Mentioned that this would be in the product in 2005.

Delphi Syntax for Generic Types will be:

type
TFoo<T> = class
private
data1: T;
public
function SomMethod(param1: INteger; Param2 :T) : Integer;
end;

function TFoo<T>.SomeMethod(...);
begin
end;

var
Foo : TFoo<Integer>;

posted on Saturday, September 11, 2004 7:46 AM

1.2.3. 64 Bit Changes for the CLR

Robert Love

JIT compile IL to native 64 bit instructions, will be optimized to specific processor type.

Sizeof(Pointer) <> Sizeof(Integer)

IntPtr type 64 bits wide

P/Invoke only works into unmanaged Win64 code.

Delphi note:

Delphi 8 with Winform's work fine with no changes.

Delphi with VCL will need some changes. Specifically because THandle is declared as Cardinal (32bit) in many places and it's size changes. So this needs to be addressed before the VCL will work on 64bit.

posted on Saturday, September 11, 2004 8:46 AM

1.2.4. Danny's .NET 2.0 talk: Part One

Joe White

Covering Danny Thorpe's preconference tutorial on .NET 2.0. This is the first of two parts (I'm writing this during the break).

.NET 2.0 is a topic that's already been covered fairly exhaustively by Microsoft and others. And yet, I've already taken two and a half pages of notes.

Highlights so far:

• Diamondback will not have any of the new .NET 2.0 features. It will target .NET 1.1.
• The version after Diamondback will support .NET 2.0 new stuff, and will come out about the same time as Whidbey ("summerish" 2005).
• .NET 2.0 Delphi will support generics and type inferencing, and may even push the envelope.
• .NET 2.0 Delphi will probably have to support partial classes, because ASP.NET 2.0 requires them.
• Delphi generics may work on Win32, but will probably only work with interfaces and maybe classes.

More detailed notes follow. They may bore you.

• You can compile against .NET 2.0 today in Delphi 8. There's a compiler switch that lets you specify which runtime version to target.
• Danny is talking technical, not marketing. Microsoft is giving a .NET 2.0 presentation later in the conference, and they got in touch with Danny to ask if their content would overlap. He said no, that wouldn't be an issue.
• .NET 2.0 will be the first binary breaking change since .NET was released, and will really test Microsoft's versioning features.
• Features and schedule really driven by Yukon
• 64-bit stuff:
• MS will not release 64-bit support in anything earlier than .NET 2.0, even though they've got it working
• Itanium 2, but not Itanium 1 (MS jokes that they have the largest installation of Itanium 1 machines in the world, and they're not going to support it)
• Assembly needs extra header flags to run as 64-bit ("I actually tested this and I know what I'm doing" flags)
• Otherwise emulated (interpreted!) 32-bit mode
• Delphi will support 64-bit-capable .NET (i.e., it can set these header flags)
• P/Invoke will bind directly to 64-bit APIs. 32-bit WinAPIs will not even be accessible.
• Delphi will support generics in the 2005 timeframe
• Type inferencing: No coding done yet, but Danny doesn't anticipate problems
• Anticipates pushing the envelope
• Better constraint syntax (as opposed to C#'s "where" that looks like SQL)
• .NET lets you, and Delphi will let you, define both TList and TList in the same scope
• C# has a syntax ambiguity that Delphi will not:

  class Boo { ... }
  void Foo(System.Type x) { ... }
  void Goo(bool x) { ... }
  Foo(Boo);
  Goo(a < b);

  C# has a devil of a time figuring out the difference between the last two lines, because when it's parsing the input, it doesn't know what the tokens mean. Delphi won't have that problem, because it knows that Boo is a class name and a is a local variable: there is no ambiguity.
• Anonymous methods: Evaluating; don't know if Delphi will have
• Same for iterators
• Partial classes:
• ASP.NET 2.0 will use "code-beside" using partial classes (not code-behind as in 1.x)
• So Delphi will probably need partial classes; Danny thinks it can be done, even with top-down parser
• Syntax: won't call them "partial"
• Side note: VB.NET 2.0 won't be able to declare generic types!
• Side note: D8 already supports XML doc comments
• Edit & Continue: Last word was, can't edit currentscope, nor anything on stack! (makes it kinda useless, doesn't it?)
• C# won't have it
• Delphi will wait and see.
• ...oops, Danny's about to start again, I'll post more later.

posted on Saturday, September 11, 2004 10:29 AM

1.2.5. Danny's .NET 2.0 talk: Part Two

Joe White

Covering Danny Thorpe's preconference tutorial on .NET 2.0. This is the second of two parts (the first is here).

Nick was blogging Danny's talk during Danny's talk. Either he found an outlet, or his laptop has waaay better battery life than the one I've got. So his blog entry is also worth a read.

Okay, picking up more or less where I left off before the bio break:

• POGO (profiler-guided optimizations)
• Why it matters: 64-bit processors have a big penalty for branches (lookahead and all that). POGO tests the app under real use, and if one branch is called 10x more often than the other, it changes the emitted code to adapt. Might even move code around to keep the most-common stuff together.
• Will only be available for Managed C++ (it's not clear why)
• MS won't license it out, so Delphi is out of luck (and so is C#)
• Pointless side note: The Delphi/Win32 compiler has a NativeInt type. Don't use it. It's going away.
• Delphi for .NET will support 64-bit processors, but VCL for .NET does not
• In 64-bit, OS handles are 64-bit
• There's still some code in VCL that has them as Cardinal
• As part of the fix, compiler will probably add warnings if you try to assign a handle into a Cardinal or an Integer, so third-party code can be fixed easily
• .NET 2.0 will have TryParse methods (hooray!), because Yukon (a) doesn't like the overhead of exceptions, and (b) reserves the right to terminate running code if it throws any exceptions at all!
• Note about CLR hosting: Load the runtime once into your process, and it sticks
• So you'd better know which runtime version you want when you start up
• Other notes: Host can remap assembly bindings (ask for Studio -> remap to a request for a D8 assembly)
• In 2.0, memory allocations will go through the host first, then the OS (because Yukon is really its own OS: it allocates all available memory, sub-allocates it to the CLR, and uses everything that's left for various forms of caching)
• In 2.0, exceptions also go to the host first (because Yukon wants to be able to terminate immediately if certain bad exceptions happen)
• In 2.0, threading goes through the host (because Yukon doesn't use threads, it uses fibers)
• Diamondback = .NET 1.1
• There will be a 2.0 Delphi release in the Whidbey timeframe
• On generics and Win32:
• Reeeeally don't want to codegen Win32 code at runtime
• Generics may exist with restriction that T must be an interface (or maybe a class)
• Don't know whether generics will be in first 2.0 release
• The Whidbey-timeframe Delphi compiler may not support iterators or partial classes for Win32
• ASP.NET 2.0:
• Provider model: "I am your login genie . if you need login services, cookies, etc., come to me"
• Web Parts: customization a la My Yahoo!
• Master pages (hell, I was doing this back in 1.0, with a UserControl for the page header, another for the page footer, and a handler in Global.asax to insert them into every page)
• Editorial note: ASP.NET 2.0's code-beside model will make a lot of users very happy, because they'll no longer be forced to make all their fields protected (and get yelled at by FxCop).
• Yukon doesn't like static variables
• Each request should be isolated from the other requests
• Static variables also introduce opportunities for memory leaks
• Problem: all Delphi-generated code has static variables, because that's how class types are implemented
• Need to relax this rule in Yukon in order to use Delphi code
• Yukon will only support .NET 2.0, not 1.x (not surprising, given that most of 2.0 was a drive to make .NET meet the standard set by the Yukon team)
• Compact Framework in Diamondback
• It should work, but you may need to use the command-line compiler
• Unless a miracle occurs, there will be no designer, because MS's designer is still screwed up and not ready for release
• Delphi 8 won't work in CF because of the way Delphi tries to ensure deterministic unit initialization order (calls RunClassConstructor, which doesn't exist in CF)
• Diamondback will try to load that method, and if it doesn't exist, will still let the app run (but won't guarantee unit initialization order)
• As reported recently, .NET 1.1 SP1 breaks Delphi 8. Danny anticipates a fix by next week.
• mscoree.dll
• Every managed app has an unmanaged entry point that calls mscoree.dll, which looks at your EXE, loads the right CLR version, and sends you on your way
• There's only one version of mscoree.dll on your system at a time (not much other way for it to work)
• Bug to note: When you install .NET 2.0 beta, it overwrites mscoree.dll (no problem). When you uninstall, it does not put the old mscoree.dll back (problem).
• .dcpil, .dcuil files have references to the Framework, and are therefore not platform-portable. To use D8 with .NET 2.0, you first have to recompile the D8 RTL.
• GC note: Each thread has its own heap, so there's no thread contention for the heap. Interesting.

And there you have it. Much info, much trivia, and I didn't blog the stuff I wasn't interested in, but this should be of some interest to the folks back home. Share and Enjoy.

I have another three pages of notes about John Kaster's talk about Diamondback, but I'm going to go get some food, and blog about his stuff later. (I will write about it later; whether I blog about it tonight or tomorrow depends entirely on wirelessness.)

posted on Saturday, September 11, 2004 6:27 PM

1.3. John Kaster's Diamondback talk

Joe White

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.

posted on Sunday, September 12, 2004 11:32 AM

Re: John Kaster's Diamondback talk 9/12/2004 2:02 PM Max

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

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

1.4. Fetch my Lino.. and drive me to ASP.NET

Dave Nottage

OK, it's a corny title.. so sue me ;-)

I haven't touched ASP.NET much yet, but Lino's session ASP.NET: Fasten your seatbelt has convinced me I should do more. This is my first and only tutorial at BorCon this year, and it included a look at Diamondback, which confirmed that C#Builder is included with it, at least in the build shown here.

Some interesting points I noted from this session:

MS's Reporting Services - apparently you can throw away all your other (web-based?)reporting systems. This one rocks. Something to investigate anyway.
Cookie based session management is a thing of the past with ASP.NET 2.0, and it's all built-in.
Falafel Software believes it should give away it's web development framework to web developers. How cool is that?

Nothing much else to report that I can remember right now. Tomorrow is a rest day for me, other than the opening keynote if I decide to go, and the reception Sunday night.

posted on Sunday, September 12, 2004 4:43 PM

1.5. ASP.NET 2.0 overview session

Dave Nottage

I firstly apologize for the lack of blog entries. This is my partners first trip to the US, and I wanted to make sure she had things to do and felt safe about going here and there. In addition, a friend of hers perished in an helicopter accident yesterday, so I've cut my sessions down today to one: ASP.NET 2.0

ASP.NET 2.0 has a lot of cool new features.

There are new classes that help you manage sessions, information about users of your web applications including membership, role management and personalization. It also provides APIs for site navigation, caching of database access and configuration management.

It also comes with an MMC snap-in for managing your ASP.NET applications, rather than having to make mods to web.config.

.Page Framework . features of ASP.NET 2.0 include:

• Master Pages - rather like base ancestor classes (if you like). Override content placeholders to provide customised content. Master pages can even be nested.
• Themes/Skins - easily change the look/feel of your apps.
• Localization - for different languages/data formats etc.
• Adapative UI - allows your app to adapt to the kind of browser the user has, eg a mobile device.

Brian Goldfarb whizzed through some demos of the page framework features, from which he built a website complete with site map, login/logout/registration, role managed users, data presentation, navigation and manipulation, all without needing to write a single line of code. Customization of themes at runtime needed just a few lines of code. The sitemap was built by manually editing the sitemap data, however I wouldn't be surprised if this can be done automatically through the IDE in the release version.

He mentioned that the build he was using is beta 1, and that beta 2 should be out soon.

Something that came out of the demo that has been discussed on the newsgroups before is automatic case-matching. I become annoyed when I see code that doesn't match the case of the original declaration, however it's something I've been against making automatic in an IDE unless it was optional. I'm rather warming to the idea now :-) eg if I declare a symbol as

Foo: integer;

I'd like the IDE to automatically change the case of references to that symbol, eg

for foo := 0 to MyList.Count - 1;

changes to:

for Foo := 0 to MyList.Count - 1;

posted on Thursday, September 16, 2004 10:14 AM

1.6. Tutorial Sessions - day 2

Serge Dosyukov

• Delphi Tips and Techniques by Brian Long
• Foundations of Service-Oriented Architectures by Kenneth Faw

Session #1: Many of us start a day with session which became classic of BorCon . Delphi Tips and Techniques by Brian Long. I think everybody enjoyed Brian .s British accent. ;o)

As usual we see some nice ways to add homey touch to your Delphi IDE (such as make visible some hidden menus, make your hints nice and colorful, some undocumented registry keys and more. Because during a session Brian used DiamondBack attendee were be able to feel a new flavor of new Delphi version, see new features and language extensions.

Session #2: My big .thank you . to Kenneth Faw, Pillar Technology Group, one of the favor presenters during BorCon (6 sessions). He did talk about SOA (Service-Oriented Architectures), not a web-service aspects of it (many of us see SOA from this perspective only), but as a full architecture for enterprise applications (remember CORBA?). Even it wasn .t many people during a presentation, I think it was GREAT. My opinion, Kenneth should have this session presented during regular tracks and for bigger auditoria. As soon as people go to enterprise market they start to make (in many cases) same mistakes, over and over & Going through major aspects of SOA architecture, Kenneth included many real life samples of building enterprise application in .Net and Java environment.

• building SOA
• detailed list of benefits
• do you have legacy system component - look at SOA architecture
• defining SOA architecture for your applications
• use of web-services in your SOA
• good and bad practices of implementing enterprise application

If you miss a session, talk with Kenneth, you will find what you can get many good ideas. It might lead to a consulting contract with Pillar TG... or might be not... ;o) Anyway, it was gooood.

posted by Serge at 1:10 AM

1.7. Test Driven Development with Charlie Calvert

Jim McKeeth

Charlie Calvert presented a preconference tutorial on Test Driven Development.

You can get to the presentation, code and notes by visiting www.elvenware.com. This is a subset of the information available there along with some of my impressions and interpretations.

Unit Testing is not tied to any methodology, but it works well with a number of agile methodologies. Related technologies include Patterns, UML and especially Refactoring. In fact you shouldn't refactor unless your code is well covered by unit tests.

A side effect of complete unit tests is they provide a specification and documentation for the project. If the tests are all created first then they provide the specification and measurement of progress on the project. When the tests pass then the requirements are complete, and the tests document the routines. Programmers would rather write and read code instead of specifications and documentation, so if a unit test, being code, provides documentation and specifications then the programmers are more likely to create documentation and use specifications. If the tests pass, and they are well designed, then they provide current documentation.

During the development process unit tests provide rapid feedback since you can run your tests early and often. This can let you know if your changes break another part of the program. It can also provide feedback to the users.

Creating the test first - that exercises only what is needed - and then a stub for the method (resulting in a test failure), then only adding the

• Create the tests first
• Only tests the required features of the method
• One test per method is the preferred way
• There may be multiple checks on the results after the one test per method
• Create an empty stub for the method
• Run the tests and it fails the new ones
• Add only the code necessary to meet the requirements of the test
• Run the tests again
• If it fails then correct the method and rerun the tests
• If it passes then continue - don't add other unexercised and unrequired features
• Refactor
• Re-test

Reasons not to Use Unit Tests

Assuming you already have reasons to use it. Don't read these reasons unless you already have reasons to use unit tests. Don't let these reasons talk you out of if completely, but just so you have your eyes wide open before going in, and also are willing do what it takes.

• It requires a lot of work as you write one or more test per method, class and procedure in your project. You should be prepared for the upfront time commitment and realize that they payoff will come later.
• It will radically change the way you write code and the way you do your projects. Testing through-out development instead of at the end.
• May cause a conflict with managers and co-workers if they don't understand the reasoning behind using unit tests.
• Unit tests should be easy, flexible and simple, and at first you may not yet know how to do them correctly.
• They are not a silver bullet. If the code is really bad, or the project is very poorly designed then unit tests will not necessarily fix it.

Unit Testing

Setup and Teardown is run before and after each test method. Tests should be discrete and independent so the order of the tests doesn't matter.

Tests should be named Test* or otherwise meet a specific syntax as expected by the framework.

Automate your tests to run as a console application, then grep the results for failures. Or some other automation where you will be notified of a failure. Tests should run during the night and multiple times during the day.

Philosophy

Four variables

• Cost
• Time
• Quality
• Scope

Let your users / management pick 3 items. The 4th one is the flexible and the developers set the level on.

XP

Unit testing is required for the other features of XP. Everything should be tested. You will write the test first, then the code. The tests should run multiple times per day.

Refactoring is the process of improving existing code. Refactor code to make it simpler and more flexible and reduce the costs of change. You need unit tests before you refactor. Refactoring is about improving design without adding new features.

Keep code as simple as possible. Never write more code than the minimum you need to make it work. Start out with the assumption there is a simple solution. If it is complex then break it into smaller pieces.

90% is easy and 10% is hard. Try leaving this difficult part out based on the concept that it will result in a more stable program in much less time for less money. If there is a choice between coding for a contingency now and doing the minimum then just do the minimum now.

With unit testing and refactoring then dealing with these possible future issues (the last, expensive 10%) can be done in the future at a much lower cost. You may never need that last 10% so you have saved the time and money. If you do need to add it later then you only pay the cost when you need it. Expect change and know that it will come, so you really cannot plan ahead (adding features for the future). Do it simply today and keep it so you can easily change it tomorrow. Make little tiny changes, iterative development, release often

Code that is easy to test is easy to use. It should be encapsulated and uncoupled.

posted by Jim at 9/19/2004 06:59:46 PM

2. Borcon Sunday Sessions and Event

2.1. Sunday at Borcon

Nick Hodges

I just got done giving my tutorial on Building ASP.NET Controls. I think it went pretty well -- I hope so. It's sometimes hard to tell. I was concerned going in that I didn't have enough material, but it worked out almost perfectly. I could have used maybe 15 minutes more, but I did manage to at least cover everything, however rushed at the end. I was using Diamondback for the demo, and it worked quite well -- only had to restart once, and I should have known better. getGiving a tutorial is a lot of work and I'm glad that it is over. ;-) It's also fun. I really like to give talks, and get pumped up when they are over. I'm always in a good mood when I get to teach.

Yesterday I went to Lino's .ASP.NET: Fasten Your Seatbelts . which was well named. Lino started at a hundred miles an hour and didn't let up for four hours, entertaining us with his vast knowledge of ASP.NET. He's done some really cool stuff on his website with ASP.NET, and was kind enough to share it all with us, including the code. Quite a good deal.

Because I went to Lino's talk, I didn't get to see John Kaster doing the Diamondback talk, where I guess he pretty much pulled back the curtain and showed all the amazing new features. Looks like Joe White has a good summary. What do I like? I like the Refactoring, the History view, SyncEdit, and integrated Unit Testing.

Tonight is the opening keynote. If I can get a wireless link in the general session room, I'll liveblog. Otherwise I'll take notes and post them after. I'm hoping that some of the questions for Dale are interesting and, ahem, shall we say .probing ..

posted on Sunday, September 12, 2004 2:12 PM

2.2. Borcon Day 1 - Sunday

Euan Garden

(Catching up with actually posting my blog notes)

Arrived Sat night, it was a nice quiet flight down from Seattle, I was able to get a row to myself and an empty row in front of me so I was able to work on my slides all the way down, although it was pretty bumpy. Might have gotten a little carried away on the flight as I have 65 slides for a 1:15 session which has a ton of demos, oops.

One of my demos is for the Microsoft Keynote on Monday, I'm doing this with Borland's Danny Thorpe I managed to track him down this morning to chat through the demo(and get some help debugging the delphi code for the demo), Danny's a pretty chilled guy so we discussed some ideas for the demo and decided we will make it up partially as we go along.

I must be getting old, I went to check out the MS booth in the show hall and instead of looking to see if we have any cool demos or giveaways on the stand, I looked to see if we had paid for the same .super padded . carpet as last year :-), luckily we do so my back and knees might actually survive doing booth duty for the next 3 days. However if you are at San Jose airport on Wed night I'll be the one limping as I am bound to be in pain by then.

I bumped into Lino, Brian and others from Falafel, they have sporting theme going on their stand this year, they also have yet another venture, CodeFez. I'd swear that Lino has more subsidiaries than MS!

Seems like Nick has been having more luck with wireless than me and has been live blogging the pre-conference sessions.

After a short spell on the booth(come and get your free SQL Server 2005, B2 T-Shirt while they last!), we headed off to the Borland Keynote. This is very unlike an MS keynote, it involves the VP for Developer Relations and the CEO getting up to some antics on stage, generally involves a T-Shirt cannon and some awards for customers and partners. This year they showed a video of the next version of their Windows and .Net IDE, even with my glasses on, sitting in the 3rd row it was fuzzy so it might be time for the annual eye test! The new CTO also showed off some long term thinking they have been doing on Software Development Optimisation(SDO) it was cool to see a bunch of BI being used, including some very soothing visualisation hardware. After the session we all headed off for the welcome reception.

I headed off for the rehearsal for Rick La Plantes keynote. We ended up doing it in his hotel room, which was bigger than the meeting we had booked. This was the biggest hotel room I have ever seen in my life, it must have had more square footage than my entire house, good job Rick was only there for 20 hrs :-)

Danny and I walked through our demo for Rick, plus the Borland and MS marketing folks, everyone seemed happy so we headed out, however we came up with an idea to add to the demo so looks like a late night ahead, it will be very cool if we can do it though.

List of bloggers from borcon with far more detail than I have:

• Craig Stuntz - http://blogs.teamb.com/craigstuntz
• Dave Nottage - http://blogs.teamb.com/davenottage/category/138.aspx
• Jim McKeeth - http://www.bsdg.org/
• Joe White - http://excastle.com/blog/
• Marco Cantu - http://www.marcocantu.com/Development/borcon2004/
• Nick Hodges - http://www.lemanix.com/nick/
• Paul Gustavson - http://www.simventions.com/gustavson/
• Robert Love - http://peakxml.com/
• Serge Dosyukov - http://borcon2004.blogspot.com/

Plus the annual tradition of Dr Bobs conference report

posted on Tuesday, September 14, 2004 10:37 PM

2.3. Opening Session

2.3.1. BorCon 2004 is opened - short

Serge Dosyukov

BorCon is opened. Some people was shoot during a presentation. Just joking ;o)

Great presentation, many people, big party after, casino, good music by great band, Dale Fuller played some music for us and through some gifts to us.

Read more in Robert's log here or Nick's here. Check others logs from a blog list, you will find more.

posted by Serge at 1:19 AM

2.3.2. Opening Ceremony

Nick Hodges

Well, here I am at the Opening Ceremonies, front row with the Advisory Board folks. I can't get a live link to the wireless network, so I'll have to .Delay Blog . tonights event, though those reading it after the event will get the .Live Blog . feel.

The main hall is a bit smaller this year, but it is crowded, and there's a festive atmosphere as we wait for David I and Dale to come out . as they always do. There are a couple of trendy looking podiums up there, and I half expect David I and Dale to out and play a little techno-pop.

David I has just come in from the back and is .working the crowd ., dancing and getting us all to clap. He's tossing a few t-shirts to the folks, and just gave me a big high five! You haven't lived until you'd seen David I dance and jump in the air. It is a sight to behold. Two punked-out girls just jumped out on stage and danced with David. I am speechless.

There's a pretty cool video playing touting Borland's .Power to create, innovate, anticipate, execute, and deliver results .. The motto this year is .Unleash the Power .. The video was quite well done.

Hey, David I's mom is here. That's cool!

David I points out that this conference is one of many. There's the European Conference at the end of the month, and one in India, China, France, and Tokyo.

David is touting the keynote tomorrow morning, exhorting us to be there and not to miss it. Tuesday is the obligatory Microsoft keynote, and Wednesday is the obligatory Sun keynote. Might be interesting, you never know. ;-)

The special event is once again the Tech Museum. I am totally fired up for the table full of Hostess products. The man who invented the Ho-Ho deserves some sort of Nobel Prize for Gastronomy. If they don't have that award, they should invent it for him.

David I just introduced Dale. He's going to talk on Borland's .Vision for the Future ..

Dale's Talk:

• Dale just said .We promised we'd never abandon the developer, and we want to keep the promise .
• .Code is King .
• The past and the future is all about Developer Productivity (I am really glad to hear them leading with this. I want to hear this. This is really good stuff for them to emphasize right off the bat.)
• Dale's making David do a Diamondback demo. David I showed a flash video with some features of Diamondback including SyncEditing, Refactoring, unit testing, and other stuff.
• Dale points out that Borland has a presence all over the world, including Cupertino, Scotts Valley, Singapore, Atlanta, and St. Petersburg. He points out that they are using their own tools to do distributed development.
• The future is to build upon and link existing and improving developer productivity to improve general business productivity.
• .Software Delivery Optimization . is the buzzword of the year.
• I think he's making a good point here: Because Borland understand developers and recognizes the .value of code ., Borland can better bubble up from the bottom the tools needed to manage development and requirements. He points out that there are lots of CASE tools out there that .started at the top . and simply don't do the job because they don't understand code and the development process.

Dale just brought up Pat Kerpan, the CTO. He's going to talk about some .concept products .. His stuff:

• He has some desktop that I think is trying to show a tool that a big picture view of a project with requirements, estimates, etc. It's pretty cheesy, to be frank. I think I know what they are getting at here, but I'm not sure. They've got David I's picture up there, and they are morphing his face to indicate how things went on the project. I am quite baffled here.
• For you Yahoo BORL board types, there's an icon for .Blue Dwarf . on the screen. Now they are talking about it. Oops, red ball on Blue Dwarf. There is some kind of Dashboard thing with status balls. Whatever.
• I don't have any idea what this is. This is really weird. Forgive me, but this is really, really strange. What in the world is he talking about? Now there's some music playing. Why? I have no idea.
• Now he's pulling out Clippy and melding it with RoboCop. I seriously have no idea what is going on here. He's done, thankfully. Sorry, but what in the world was that?

Log.Sec Corporation won .Application of the Year ..

Hewlett-Packard won an .Application of the Year . award as well.

And so did QMedtrix for a Delphi application that manages medical billing product called BillCheck.

The Partner Solution of the Year goes to Dunn Solutions Group.

The Trainer of the Year goes to Tom Margrave from Orasi Software. (He's a StarTeam trainer).

The Technology Partner of the Year goes to four folks: AutomatedQA, BusinessObjects/Crystal Reports, Segue Software, and Woll2Woll Software.

The University of the Year award goes to Carnegie-Mellon. Borland gave them $1,000,000 bucks! Wow.

The President's Award . i.e. The Big Check to An Employee . goes to Allen Bauer. Very well deserved. Allen is a great guy and a dedicated Borlander.

posted on Sunday, September 12, 2004 8:26 PM

2.3.3. Unleash the Power - From the BorCon Opening Session

Robert Love

I am sitting in the front row of the open session this year there are some tables... I only can assume to make it easier for us to blog... ;-)

I am sitting next to Marco Cantu, he has a camera and you can see pictures of the session as it occurs!

The session started with David I dancing through out the crowd. Then they began tossing Green T-Shirts. David I has never looked better ;-) you will have to check out Marco's Site in a few minutes to understand why.

They reminded of several key sessions. Stop back by here on Monday Night. 8pm MST - where I will be in the Diamond Back Preview and Meet the Team sessions.

David welcomed Dale Fuller, CEO of Borland, his 6th BorCon session since starting with Borland.

Dale Fuller recommitted the promise his original promise not to forgot the core of there business... The Developers!

Dave I.. showed a video previewing Diamondback. Here is what I caught, it was going by really really fast!

• Refactoring: Rename Method, Auto Declare Variable
• Unit Testing
• Win32 and .NET
• Code Change History Window

Dale Mentioned the following

1/3 of all Development Projects are never completed. Everything resolves around the .Code . and Borland's Tools that focus on business are designed to improve the process of getting to the .Code. .

Then the CTO was welcomed out (Missed his Name)

They showed ideas on how you might want to tracking of software development. I got the impression that something big was going to be shown tomorrow morning.

Then they started to present the Annual Awards

Customer Application of the Year

• Log.Sec Corporation
• HP
• Qmedtrix Systems Inc.

Partner Solution of the Year

• Dunn Solutions Group

Trainer of the Year

• Tom Margrave Orasi Software http://www.orasi.com

Technology Partners of the Year

• Automated QA
• Business Objects (Crystal Reports)
• Segue Software
• Woll2Woll Software

New Award This Year: University of the Year

• Carnegie Mellon's University

Then they received a $1,000,000 check as the award. The Dean was able to to talk after the award and he mentioned that his students like to use Borland products.

President's Award

• Allen Bauer

Allen seemed happy the check associated with his award.

Then Dale came back out with the T-Shirt Cannon!

Then they let us go for a party!

posted on Sunday, September 12, 2004 4:03 PM

2.3.4. Opening session and opening keynote

Joe White

I'm posting this a little late, since Nick already posted about this stuff. I'll just add on to what he had to say.

Opening session (Sunday night)

There was the obligatory light show (the lightning effects were pretty cool; I wonder what kind of equipment they needed to make that work), techno music (they should sell the soundtrack), and abstract computer-generated videos (I particularly liked the mood-lit clocks and the plasmafied ASCII). It was interesting to watch DavidI getting bouncy. And the dancing girls were an interesting bit of spice, with their 80's hair, and what couldn't exactly be called miniskirts . they were really more like mini denim loincloths.

This is Dale's sixth BorCon, DavidI's 19th, and DavidI's mom's first. (He apologized to her about the dancing girls. It's not clear whether he actually even knew about them.)

The new buzzword is "Software Delivery Optimization", which extends ALM. They basically make it a continuum:

• Build software (Delphi, etc.)
• Build software right (ALM: CaliberRM, StarTeam, etc.)
• Build the right software (SDO)

The basic idea is to extend the process up to the decisionmakers, and make sure they're involved in knowing what the costs and risks are of changes. I'll be interested to see what all they come up with for this.

They pointed out that people have tried this before, with things like CASE tools, but those focused on the business needs and not the code. Borland, being Borland, focuses on the code and grows from there.

I'll have to see if I can drag our director of development to BorCon next year. There's a fair bit of stuff for him to chew on.

Opening keynote

I agree with Nick: San Jose Taiko's performance was very cool. The song they started with was called "Matsuri", which means "festival".

More about SDO, including the skit. I liked the programmer's comment, when the "project manager" came over and said "good morning": "Why is it a good morning? It's 8:28 am. Talk to me at 10:00."

The interesting statistics they cited:

• 30% of software projects are canceled before completion
• 54% are over budget
• 66% are not considered successful by their companies
• 90% were delivered late

And the big reason is that management makes decrees that have a huge impact on the timeline (their example was "we need a new feature, and we need to move the deadline up by a month, and we need to take five people off the project" . the end result was "we can do it, but we need to keep those five people on the project").

They also talked about new projects on the horizon: Project Themis (team infrastructure, coming first half of 2005), Project Hyperion (visibility and predictability, coming in 12 to 18 months), and Project Prometheus (enterprise resource planning, also coming in 12 to 18 months).

Lots of buzzwords. I hope they offer some good sessions next year that give us a solid sense of what this stuff means.

posted on Monday, September 13, 2004 2:04 PM

2.3.5. WHOO! *Happy dance*

Joe White

Had to blog this first thing.

I have, in my hot little backpack, a two-CD set of the Diamondback Preview. They handed them out to everyone after the What's New in Diamondback / Meet the Delphi Team session tonight. (Now aren't you sorry you missed the con?)

New toy. Hehehe...

Yes, it's beta, yes it's going to do some crashing. But... refactoring, man. Find References. Sync Edit. Debugging .NET and Win32. Delphi and C# in the same project group. I'm going to have some serious fun with this thing, especially after I get back home.

Oh, and a note for the guys back home: The Diamondback Win32 compiler still supports old-style objects. So we could use this thing's refactoring tools to migrate them to classes. How long have we been waiting for that?

Wheeee...

posted on Monday, September 13, 2004 9:40 PM

2.4. Borcon Opening Keynote

2.4.1. Live Blogging from the Borland Keynote

Nick Hodges

Well, here I am at the morning keynote. I'll live blog for as long as my battery hold out.

There is a wonderful Taiko Drumming Band performing. I love Taiko drumming, and am loving it sitting right here in the front row.

David I just came out and played with them! How cool is that! Very well done.

David just introduced Boz Elloy. His topic .Maximing the Business Value of Software ..

Borland's Vision is:

• Continue to build software for software people
• Continue to server the needs of software creators
• Broaden our outreach to help .other . software people (Managers, analysts, etc.)

More on the buzzword of the day .Software Development Optimization .:

He just promised us a .Borland Roadmap in some detail ..

I like Boz. He seems like a cool guy.

They are running a little skit about changing requirements on a theoretical .iPets.com . site. They are showing off their new EstimatePro tool. The Borland System Engineers are doing the skit. It's pretty good, actually. They are funny, but are illustrating the features of CaliberRM really well. They are demoing the process of managing a change and resource change to an application. This is well done.

I'm jealous. They are demoing the Caliber and Together stuff integrated right into JBuilderX. Very slick.

These guys are funny and getting a lot of laughs.

Boz is back now.

He's talking about how developers are the .gods ., creating something out of nothing. But he doesn't think we have all the tools that we need to be successful. We have the development tools, but there is more to success in developing software than just development tools. Software developers may not have the knowledge to properly manage and deploy software.

Three myths of Software Development

• It's an engineering discipline -- we have a ways to go before its truly and engineering discipline
• It's only about the bits -- they have to be the right bits
• It's different from other managed business processes -- It can actually be very like a physical manufacturing process with things moving through the system.

What has been done to improve and optimize the software development process? Software optimizes other business processes, but what about our business processes?

If you are in business, you are in software. If you turn off the software, you turn off the lights. Software must be a core competency for all business.

Being good at Software is:

• Increasing the ability to Target and capture opportunities
• Decreasing the time to production of software
• Decreasing the risk of software projects and increasing predictability
• Decreasing the cost
• Increase the quality

But in fact, the industry is failing at this. Reasons why:

• Competing business priorities and resources
• Constant change and shorter release cycles
• Distributed teams and external resources
• Increased complexity and mixed environments
• Inability to properly deploy the application

Boz is talking about a lot of good stuff, but it's higher level management stuff, so it's not really anything that can be blogged really well.

posted on Monday, September 13, 2004 8:47 AM

2.4.2. Welcome Keynote and Reception

Jim McKeeth

The welcome keynote opened with a rock concert theme. Mostly just a welcome out. Dale renewed his personal and Borland's commitment to the developer and writing code. "It's all about the code" was his mantra for the evening.

This is a picture from right before the keynote began. These are the same photos I used earlier, but they came out much better this time. Christine Ellis is right in the middle with the 2 screens behind the large logo, and then the large screens to either side of the stage.

Dale commented that more companies were standardizing on Borland's tools. Borland tools were involved in sending the rover to mars.

There was a really interesting presentation on the future of software metrics. They took real Star Team data and represented it in interesting ways. They used video morphs of David I, that varied from a devil to an angel, based on the measurement of change requests and code check-ins. They used midi music based on code metrics for submitted code changes. Project status was displayed with ambient orbs. There were a number of the creative ways of looking at development team data.

I actually got a chance to visit with David I. later in the computer lab. He said that the demo actually used real data from Star Team, and the representations were actually based on this real data. Only the user interface was flash. They are going to have parts of it on display in the computer lab, and maybe a write-up on BDN.

Visiting with David I. was a real treat. He is a very intelligent individual, and he takes software development and application life cycle management very seriously. I had heard a lot of comments from him up on stage, and read his "Sip from the Firehose" column, but when you sit down together after a long day around midnight you can tell the conversation is very candid. He is 100% in what he says up on stage and in his commitment to software developers. Borland has a great asset in him.

A panoramic shot of the whole reception hall. To the left we have the casino tables. Then some food (it was everywhere, and pretty good even), a dance floor with a live band and video games (lots of them, everywhere!)

Immediately following the keynote was the opening reception. There was plenty of good food, Casino gambling for door prizes, and dance band (that was rather loud), dancing, and drink coupons. I took some photos and mingled a little bit. I talked to Marco Cantu, Malcom Groves, Dr. Bob, Christine Ellis, Robert Love and Dale Fuller. Not that I expect any of them to remember me.

In my brief visit with Dale he mentioned that most likely there wouldn't be a new Kylix release unless something changed. As we all know things could change tomorrow. He said there just really was very little demand for it, which is unfortunate, it is a good product. It is good to know that if and when things do change on the Linux platform, Borland will have a development tool that can be updated quite quickly.

In the immediate future, if you want to use a Borland tool to develop on Linux you actually have a few other options. I think C++Builder X could be used to target Linux, although the IDE would not run on it. Also JBuilder should run on and target Linux (since it supports a JVM). I don't use either of those tools, so I am not sure on the details. Now with Mono 1.0 release you can use Delphi 8, C# Builder and soon Diamondback to target the Linux platform, just don't use the Delphi SysUtils unit (someone needs to make a safe version of SysUtils to target Mono.)

posted by Jim at 9/19/2004 10:42:01 PM

2.4.3. Live from the Opening Keynote

Craig Stuntz

Wireless coverage is spotty, but I have a good connection now, so I'll take advantage of it. Quinn Wildman recruited me to give a short presentation on InterBase Performance Monitor to his "Introduction to InterBase, Part 2" preconference this afternoon. I showed the first public preview of the new version of Performance Monitor, which includes support for new performance monitoring features in the upcoming 7.5 release of InterBase.

InterBase 7.5 adds two new monioring tables to the seven already available in older versions of IB 7. For those unfamiliar with this feature, it allows you to see ingreat detail what's happening inside of an active InterBase server and what your users are doing, and to take control if necessary. All of this is accomplished by simple sQL statements, though you can use my GUI app if you prefer. The two new tables allow you to see details of triggers in use by the server, as well as a very low-level view of how InterBase is using server memory.

In addition, the database performance monitoring table adds features which allow you to flush the write cache, release server memory, and trigger the sweep via UPDATE statements (or viabuttons on the GUI application.

David I has started the opening keynote address now, so I'll stop typing and listen.

posted on Sunday, September 12, 2004 9:22 PM

2.4.4. Diamondback at Opening Keynote

Craig Stuntz

David I showed a short video which (very briefly!) demonstrated new Diamondback features. It was hard to make out what was on the screen, but I noticed live help in the code completion dropdown (in a window to the side, which displays info about the method currently selected), and unit testing. Also a JBuilder-like (and very cool) sync edit. Select a segment of code, turn on sync edit, and start typing over an identifier. The change is applied to every instance of that identifier in the selection as you type.

posted on Sunday, September 12, 2004 9:52 PM

3. Borcon Monday Sessions and Events

3.1. Borland Keynote

3.1.1. Monday's morning keynote session

Serge Dosyukov

David I have continued a yesterday Dale .s music line and joined Taiko group (Taiko? Read this http://www.taiko.com/rollingthunder.html). Drums - Great wake up call for us.

Boz Elloy holding a keynote session about Borland vision of software delivery optimization (http://info.borland.com/conf2004/keynotes.html).

After short introduction he passed it to a Borland team to talk about SDO in action. As a sample project iPet.com #2 is shown. CaliberRM in a team planning and development...

Nice phone conversations between team members in a mean time. Next step was to address requirement changes to a development team (automatically via CRM notification) to JBuilder X team into UML diagram which then posted into StarTeam Repository (integrated into IDE)... passed to next member of development team (notification and distribution)... two clicks and we have a code created which then passed to QA team which by time Mike come to QA department they already notified and almost done their job... and only need to change status of the request to go to deployment... and... done... version #2 defined, implented and deployed...

And then come to Boz with next presentation about Borland vision for software development ...

Borland saying - it is time to step forward from just development to a fully managed process from definition, design, implementation to QA and delivery... "getting good": decrease cost of the project, decreasing a time of the project, making project successful and delivered at time...

Borland answer to development problems - Software Delivery Optimization.
I am not very fast in typing, so I let other guys to give more details on each aspect in of SDO by Borland... Check blog list for more details. For example, Nick has very detailed blog about a presentation here http://www.lemanix.com/nick/.

Then there were some comments from Borland team about how Borland strategy IS working within Borland software development cycle.

Borland is going to make it available for Delphi developers next year.

Borland plan to change a way how products are packaged and distributed: product line will be more segmented and target specific needs of development teams instead just having Pro/Ent/Arch versions.

New projects were announced which address different part of development cycle:

Prometheus - ERP for software delivery

Hyperion - visibility and predictability

Themis - team-work infrastructure

We will see them integrated in current environment one by one during next few years.

As a main next stage of evolution of Borland platform for 8 months - resource and project management, process automation and optimization (this segments are part of first two project).

Next exciting news was announcment of the new versions of products

• JBuilder 2005
• StarTeam 2005
• Caliber 2005

Note. Borland finally decided to go with year based versioning

As a closing point of the presentation we saw one of features of upcomming DiamondBack - NUnit based testing

And then, just in case if someone fall asleep during presentation, we had a Taiko team with David I again.

posted by Serge at 9:17 AM

3.1.2. Monday Morning Session

Robert Love

The session just started, and the drums are ringing, after hearing from the Japanese drummer's David I entered the stage and joined them in playing. After a short introduction he welcomed Boz Elroy on stage.

Maximizing the Business Value of Software

It's not just about doing it faster, its about doing it better.

Borland Vision - Long Term Vision

• Continue to build software for software people
• Continue to server the needs of the software creators
• Broaden our outreach to help .other . software people

They call this vision Software Delivery Optimization

Then started a funny but realistic role playing situation began to roll out for iPets.com

During this they used the following product.

• New product SPC Estimate professional
• Caliber RM
• JBuilder X
• Together
• Optimize-IT
• Borland Management Console

The Executive request a Change and then then use the tools to track risk, and the progress all the way through the development process to the QA. Then moved it on to Operations, to deploy the product into production.

Lets facts: Forces that impact the gods of software (developers)

• Poor prioritizing of projects
• Poor management of people to projects
• Poor Management of requirements and Scope
• Poor Visibility into and across the process
• Poor process automation governing consistency across teams and timezones
• Poor understanding of what it takes to roll an app into

Forces come from: Decisions Makers and Operations

Software has been written to optimize most business processes, however software development has been neglected.

• 30% Canceled before they are finished
• 54% Delivered over budget
• 66% Were not considered Successful
• 90% Delivered Late

Why?

• Competing business priorities & resources
• Constant change & shorter release cycles
• Distributed teams & External resources
• Increased complexity & mixed-It environments
• Inability to deploy even though developed on time

Borland's answer: Software Delivery Optimization

• Maximize Opportunity
• Accelerate Delivery
• Mitigate Risk
• Ensure Quality
• Reduce Spending

With all of the bullet points above, the short answer is Borland is trying to resolve the problems found in Software development. Software development is process that starts well before it gets to developers and ends out side of the developers with deployment. Borland will be providing tools to resolve these things.

Roadmap...(12-18 Month Focus)

Project Themis - Team-Work Infrastructure (New Product 1st Half 2005)

• Initially, 4 distance roles addressed
• Analyst, Architect, Developer, Tester
• All platforms supported (Includes Delphi Support)

Project Hyperion - Visibility and Predictability

Project Prometheus - ERP for Software Delivery

Announced the following products

• JBuilder 2005
• StarTeam 2005
• CaliberRM 2005

Then they are going to give a quick showing of JBuilder 2005 and DiamondBack (Delphi)

JBuilder

• Drag and Drop of CaliberRM Requirements into the source code
• Distrbuted Refactoring
• Code Security Audits from Fortify (Subscription based updated to detect regular updates.

Diamondback (Delphi/C#/Delphi for .Net)

• Unit Testing (Both NUnit and DUnit supported)
• Auto created basic testing framework code.

The rest will be shown tonight at the Diamondback Preview.

--over and out--

posted on Monday, September 13, 2004 6:03 AM

3.1.3. Diamondback and JBuilder 2005

Jim McKeeth

JBuilder 2005

Calibur RM (Requirements Management) intgrated client, integrated refactoring that communicates with all developers. Built in support for security audits on the code from fortify - could be run automatically.

Delphi Diamondback

Built in unit testing support. Supports both NUnit and DUnit. Greater functionality for building tests then previously available. Plus many, many new features.

It looks like alll the productivity features previously available in JBuilder are now in Diamondback. Looks like features are being added to both at the same time.

posted by Jim at 9/13/2004 10:41:21 AM

3.1.4. Kylix community project

Jim McKeeth

They just announced the Kylix community project. Teaming up between Borland and community leaders to keep CLX up to date.

posted by Jim at 9/13/2004 09:13:47 PM

3.1.5. Unit Testing in Diamondback at Monday General Session

Craig Stuntz

Michael Swindell demoed unit testing in Diamondback at Monday morning's general session. Very slick. There's nothing added that you can't do already with DUnit or NUnit, but with Diamondback it's much, much easier. Write your class, then complete a couple of wizards to create a corresponding test project and test suite. The IDE generates the testing framework for you, and you just fill in the code for the tests themselves. You can run the tests within the IDE. This feature should significantly increase the use of unit testing in the Delphi community.

posted on Monday, September 13, 2004 2:49 PM

What'a New in Diamondback

3.2.1. What's new in Diamondback - Allen Bauer

Robert Love

Allen Bauer's Presentation will be focused on the IDE specifically.. the room is packed (standing room only)

Multiple personality IDE

• Delphi Win32
• Delphi for .NET
• C#

Debugging

• Win32 & .Net debuggers working simultaneously.
• Debugging .Net code hosting a Win32 process
• AppDomain support in the Module View for managed apps. (App domains show up in the modules panes and in the scope browser pane)
• Soring in the modules view
• Better stack traces in Win32 apps (for frames that don't have Debug Info) (Even after an Exception!)
• Locals view allows for changing frames in Win32
• Exception notification dialog enhancements
• Break/continue buttons
• Ignore Exceptions type check box
• .Net exceptions now show the exception message on dialog
• Unicode enabling view that show program data (watch, locals, inspector, stack, etc...)
• Connect to IIS better
• Better evaluators
• CPU View

Refactoring

• Rename detections naming conflicts
• Extract method
• Extract Resource string
• Sync Edit
• Find unit or namespace
• Declare Field
• Declare Variable
• C# & Delphi (Win32 & .NET)
• Refactoring will cross languages, if you change a C# symbol and it is used in Delphi code the engine will change both!!!
• Will refactor DFM Values as well.

SynEdit

• Select a section of code and press the SynEdit Button or Shift-Ctrl-J
• Then you can tab through common symbols, and change all symbol of the same name at the same time.
• This is COOL!

VCL Designer

• Floating Designer will be supported!!!! Even for VCL for .NET (But not Winform's)
• Drag and Drop from the component palette is now support instead of just click and click. (BTW click and click is still supported)

Structure View

• Similar to Object Tree View
• Shows Errors from Error Insight (see Below)

Error Insight

• Shows Errors by underlining
• Such as undeclared identifiers.
• Does not require a Compile

Component Palette

• Custom Categories allow you to move components for other sections in your own.
• Completely Customizable
• Icon Size
• Show Caption's
• Plus (5-15 More options that I could not record fast enough)

Project Manager

• Has File Management functionality
• Shows Source Tree
• Right Click (Rename)
• Right Click (Add Folders)

File|New Other Dialog

• Much better,tree view down the side instead of all of the tabs.

Help Insight

• If you place your mouse over a symbol
• It will tell you where it is declared and the parameters.
• If an Xml Document is generated for the given symbol it will give that help as well.
• If a parameter has help it you can click on it an see the help for that parameter as well.

History Tab

• Shows all of the changes that you have made to the file.
• Saves X number of changes to your file.
• Easy to revert to a previous copy
• Diff Viewer to see all of the changes.
• Does not require Star Team
• Enhanced if Star Team is installed because you see items in the repository as well.

Then he ran out time, after talking with him he covered < 20% of what is new!

posted on Monday, September 13, 2004 7:57 AM

3.2.2. What's New in Delphi with Allen Bauer

Jim McKeeth

Allen Bauer, Borland's Principle Architect, presented What's New in Delphi. I took a three panoramic shots of his session:

This is from my seat in the back row. Robert Love is sitting right next to me, but I cleverly cut him out so his head wouldn't takeover the entire photo.

I took this picture while standing up at the back of the room. In this one you can see the top of Robert's laptop screen, and a ghost image of half of the back of his head. I didn't cut him out so well this time.

Again standing in the back, but this time with the zoom turned on. The guy in the blue shirt laying on the floor to the left is none other then Nick Hodges. Being on the advisory board must be hard work.

---

And here are my session notes:

Mostly covering IDE features since that is what Allen Bauer spends most of his time working on.

A full house in a double wide meeting room (the biggest they have next to the main hall), and this session is going to be repeated.

Galileo is a multiple personality IDE. Diamondback has DelphiWin32, Delphi.NET and C# in this single IDE. Diamondback is still a little "out there" on the roadmap. It is not pending release.

Debugging

• Win32 & .NET debuggers working simultaneously.
• Debugging .NET code hosted in a Win32 process.
• AppDomain support in the Module view for managed apps (App Domains show up in the module panes and in the scope browser pane.)
• Switch between C#, Delphi Win32, Delphi.NET during same development session.
• Sorting in the modules view
• Exception notification dialog enhancements
• Break / Continue buttons
• Ignore exception type checkbox
• .net exceptions now show the exception message on dialog
• Breakpoint view
• Supports in-place editing
• Check box to quickly enable / disable breakpoint
• Toolbar
• "Log call stack" breakpoint action
• Multiple debuggers
• Debugger registration
• Betted IIS connection
• Cassini webserver support (still)

Refactoring

• Rename
• Renames all occurrences of a symbol, entire scope
• Will rename occurrences in a Delphi and C# assembly at the same time, if one references the other
• So if a C# assembly declares a symbol and a Delphi assembly uses the C# assembly then it will rename it all occurrences of a symbol that is shared between the two.
• This is not a regular text search and replace
• Does not effect comments
• If an unrelated symbol has the same name it is not renamed
• Looks at descendent classes
• Will alert about possible conflicts
• Extract method
• Create a method out of a selected block of code
• Extract Resource String (Delphi only)
• Sync Edit
• Edit all occurrences of identifiers within a selected block of code.
• Specifically for local scope editing, does not take scope or unselected code into consideration. Not a replacement for rename.
• Find unit or namespace
• Declare Field
• Declare Variable
• C# & Delphi (Win32 & .NET)

VCL Designer

• Choose between embedded or floating designer
• Also has docked and undocked views
• Improved drag and drop design support.

Lots of cross product pollination between JBuilder and Delphi

Greatly enhanced tool pallet by Corbin Dunn.

If you rename a unit identifier (in any of a number of places) it corrects the name everywhere.

History file lets you compare and backup from multiple history backups

Makes heavy use of community tools - AQTime, Virtual TreeView, etc.

posted by Jim at 9/19/2004 06:37:35 PM

3.2.3. Allen Bauer's "What's New in Diamondback" session

Joe White

Covering Allen Bauer's BorCon session on what's new in the Diamondback IDE.

Looks like Nick wasn't doing a live blog of this one, so I'll post my comments.

Consider this to be a follow-up to my notes from John Kaster's preconference tutorial on Diamondback. I won't cover any of the overlap here.

Allen started by saying he would mostly cover IDE features. Fair enough. Danny (who knows me by name, BTW) will cover the compiler stuff this afternoon, and the "Meet the Team" tonight will cover even more.

He's talking about features in a product that's not finished yet, BTW. Ship dates haven't been decided yet, features haven't been decided yet. This is a very new thing for Borland. (He mentioned that he's allowed to talk about anything except release dates, product names, and bundling/pricing. Very cool.)

• Debugging features
• Debug .NET code hosted within a Win32 process
• May not be able to seamlessly "Step Into" from Win32 code into .NET code
• AppDomain support in Module view
• Better stack traces in Win32 for frames without debug info. Think EnumFonts; you didn't used to be able to see a stack trace when Windows calls your callback function, but now you will.
• Locals view and stack frames: Yes, it will work even after exceptions! Woot!
• Look at different threads' call stacks and Locals views
• Same operations in both Win32 and .NET debuggers
• Refactoring
• No distributed refactoring in Diamondback, but they have underlying architecture to support it
• Refactoring works across projects within a project group, even between C# and .NET
• Based on actual uses list, not just what's in the .dpr
• Only works within current IFDEFs
• Sync edit: Can Tab through distinct symbols
• "Live Templates" (Ctrl+J templates with this Tabbing to fill gaps) won't be in Diamondback but are on the plate
• IDE is theme-enabled! Transparent panels & checkboxes, even at design time
• Component palette is drag-and-drop even in VCL
• Marketing has always claimed that Delphi supports "drag-and-drop" GUI development, but Allen commented that it was really "click-and-click"
• Now you can actually drag a component off the palette and onto the form
• Yes, click-and-click development still works. So do double-click and Shift+click.
• Component Palette in Diamondback probably won't support one component in multiple categories, yet.
• Object Inspector shows properties for files and projects. Can rename a file using Object Inspector, even if it's not saved yet!
• Carries rename through to the disk file
• Doesn't do anything to the old .dcu file (alas)
• Rename Class refactoring even reaches into the .dfm
• Also, if you rename a form class, it will rename the global Form1 variable in that unit
• History view: If you had 30 revs of a file, and you change the setting to only save 10 revs, it will not delete the old revs, and will continue to keep 30 revs for that file.
• Borland devs use AutomatedQA apps (I should've asked which apps)
• IDE uses VirtualTreeView

posted on Monday, September 13, 2004 10:56 AM

3.3. More New IB 7.5 Performance Monitoring Features

Craig Stuntz

I gave my session on InterBase Performance Monitoring this morning. I was pleasantly surprised to see good attendance in spite of the fact that my session was concurrent with Allen Bauer's "what's new in Delphi" presentation.

In addition to the features I mentioned yesterday, IB 7.5 introduces three new server maintenance functions accessible through simple UPDATE statements against the TMP$DATABASE table (or via buttons in my free IB Performance Monitor GUI application).

You can now:

• Flush the disk write cache.
• Reclaim memory by compacting the heap and discarding unused procedure and trigger clones.
• Start the sweep thread.

...via the performance monitoring features.

In addition, the GUI app has been significantly updated by me and by Andreano Lanusse of Borland Brazil. It now features the ability to save the displayed data in several different file formats, show additional columns, hide internal queries and other data resulting from the Performance Monitor app itself, and much more. I'll try and release a public beta soon -- it delivers enhancements for users of IB 7.0 and 7.1, not just 7.5.

posted on Monday, September 13, 2004 3:01 PM

3.4. Microsoft Keynote - from Borcon

Robert Love

Hopefully this is a good session, I have been bored many times in the Keynote sessions, I like technical details and the industry keynotes tend to be a bit higher level.

Marketing Hype so far with nothing much to report :-(

Talked about the Dynamic Systems Initiative (DSI) which I had not heard before it uses an Xml Schema to keep different systems together. I guess I will to search and read about that.

Then the started talking about SQL Server 2005, and how you can write Managed Code Stored Procedures.

Yeah, Danny Thorpe was just welcomed out on stage!!!

Using Delphi 8 with the command line compiler you can specify .NET 2.--clrversion=v2.0.40607

They compiled a Delphi function into an assembly, then loaded it into to SQL Server and then they wrote the same function in TSQL then they used the same function in a performance test. (i.e. Delphi code as a Stored Procedure)

Execution

• TSQL time: ~10,000 ms
• Delphi time: ~110-190 ms

Then the mentioned SQL on 64 Bit Platform, and the same Delphi Managed code will run there with no changes.

Then they wrapped up showing CaliberRM integration with Team Foundation Server and MS Project, which seem quite seamless and easy

posted on Monday, September 13, 2004 9:30 AM

3.5. Delphi 8 and SQL Server Yukon

Craig Stuntz

I'm watching Danny Thorpe and Euan Garden demonstrate writing managed code stored procedures using Delphi 8 and SQL Server Yukon. Since D8 uses the 1.1 version of the .NET framework and Yukon requires 2.0, this may seem unusual. Turns out all you have to do is specify a switch to the dccil command-line compiler indicating which framework version you'd care to target, and it works fine with framework versions which didn't exist when D8 was released.

I'm wondering what, if anything, this might offer in terms of solving the problem people have been having with .NET 1.1 SP 1...

posted on Monday, September 13, 2004 3:12 PM

3.6. Borcon Day 2 - Monday

Euan Garden

As (un)planned I was up late last night working on a new part of the demo for today, as such I slept in (missing 2 alarm calls, ooops) and missed Borlands keynote, lots of the bloggers I posted yesterday were there though if you want to see the notes.

Met up with everyone for the key note at 10, which left us 90 mins to get setup and tested, had to reboot my laptop a couple of times which was making me nervious but it seemed fine. We rehearsed the new demo, but we forgot to tell Rick we were doing it, woops.

I thought Ricks keynote went very well, he got through a lot in an hour, the first demo that Danny and I did went like this:

• Danny wrote a Delphi class that performed string splitting and manipulation, he then compiled it using the delphi for .net compiler but tagetted the 2.0 version of the frameworks using the commandline compiler instead of using the ide version.
• I then loaded the generated assembly into SQL Server and exposed the function that Danny wrote as a SQL Server function using SQLCLR.
• I then wrote a T-SQL version of the function.
• Then we ran the T-SQL and .Net versions to compare perf, the .Net version took ~100ms and the T-SQL version took ~10,000ms. There was applause from the crowd :-)

For the second demo:

• I exposed a SQL Server function as a Web Service using our new HTTP Endpoint technology.
• Danny imported the WSDL into Delphi 8 and it generated a proxy.
• Danny had a simple little UI that called the web service with a parameter and then displayed the results. Once again there was applause :-)

Post Keynote I chilled a little and did some booth duty(my those T-Shirts are flying out the door), then I went to a session on Borlands new data engine for .Net, interestingly enough they write it in a Java and then have a compiler that generates C# code, so it is 100% .Net and can run on top of Compact Frameworks. They are not shipping it yet but they hope to next year.

The first part of the evening was spent on booth duty, answering questions and doing demos, I was glad off the padded carpet by the end. Afterwards I went to the Borland Delphi meet the team session that was packed, as in standing room only, where they showed the new Diamonback Preview release, they even gave out CDx.

So now its time to start prepping for my session at 8(ouch!) in the morning, as is always the case I am adding a couple of demos at the last minute, although I did manage to get my slide count down to 52, shoulf be a snap in 75 mins...

posted on Tuesday, September 14, 2004 10:59 PM

3.7. NDataStore

3.7.1. New Borland Product: nDataStore

Robert Love

Notes on what features it has:

• jDataStore Code ported from Java -> C#
• First Class .NET Database
• 100% Managed Code written C#
• Local connection is done In Process
• Remote connection is done remotely.
• Fault Tolerant
• Delphi/C#/VB Stored Procedure.
• On disk structure identical for:
• .net framework
• .net compact framework
• Linux/Solaris (jDataStore)
• 1.1M Deployment for .NET Framework
• 925K Deployment to .NET Compact Framework

My personal thoughts: This is a unique and exciting technology to try. There is only one other database that I know of that supports Managed Code Stored Procedures and that was the SQL Server 2005. However, nDataStore has a smaller footprint, and looks like it will work well as an embeded database.

posted on Monday, September 13, 2004 12:44 PM

3.7.2. NDataStore

Craig Stuntz

I'm listening to Steve Shaughnessey talk about NDataStore, Borland's .NET native DB server. Some folks might be familiar with JDataStore, Borland's fast, cheap Java native DB server. Jens Ole Lauridsen took the front end of a Java compiler, removed the byte code emitter, and converted it to emit C# code. Steve and Jens tweaked the conversion until they could build NDataStore from the JDataStore source code. 95% of the source code originates in Java -- the remaining 5% is the binding to the .NET environment which is unique to NDataStore and written in C#. The final product is 100% C# and deploys as a single, 1.1 MB DLL.

There's a second version for .NET Compact Framework which is essentially the same product less fail over, the remote server component, and a few other things which are less useful on a handheld.

JDataStore, NDataStore, and the CF edition of NDataStore use identical file formats. So you can build a DB on Solaris with JDataStore, and copy it onto a handheld device and open it in NDataStore. This is unlike SQL Server's CE edition, where you can't even build a DB on a PC. NDataStore is also smaller than SQL Server CE, both in terms of install footprint and DB size.

Steve showed benchmarks comparing the .NET and Java editions and "native" MySQL vs. .NET and Java. He also compared in-process local execution with execution via the remote driver. The tests were performed using a subset of the TPC benchmarks. He first increased MySQL's low default cache size to a level on par with NDataStore and made MySQL's sort buffer twice as large as NDataStore. He tried with and without logging with MySQL and left sync_binlog at its default of false, sacrificing guaranteed crash recovery, which should help MySQL's performance at the cost of data integrity.

Populate DB

Lower numbers are better

45.596 JDataStore local
51.775 NDataStore local
72.284 JDataSore remote
74.117 MySQL (no logging)
105.390 MySQL (with bin logging)

Create Indexes

Lower numbers are better

2.263 JDataStore remote
2.323 NDataStore local
2.754 JDataStore local
14.761 MySQL
16.233 MySQL with Bin logging

TPC-c New Orders

Higher numbers are better

7796 tpm NDataStore Local
6922 tpm JDataStore Local
6631 tpm MySQL (big advantage due to sync_binlog)
6526 tpm MySQL bin logging (big advantage due sync_binlog)
5988 tpm JDataStore Remote

The Java->C# converter also automatically translated all the tests which have been built for JDataStore over the years.

NDataStore inherits all of JDataStore 7's fault tolerance features, including failover mirroring. JDataStore/NDataStore use a log file, but it's managed automatically -- no administrator is required.

At 5:00 today, Jens Ole Lauridsen will be demonstrating how to use Delphi and C# to write DB triggers, stored procs, and UDFs for NDataStore using both the normal framework and CF.

posted on Monday, September 13, 2004 5:44 PM

3.7.3. NDataStore

Joe White

I had a lot of questions, and they answered most of them right away:

• Transactions? Yes, full transaction support including rollback and disaster recovery
• Client/server? Yes (but also supports local in-process)
• SQL? Yes (SQL-92)

Here's the rest of my notes:

• Short answer: Yes, this is a real database.
• ADO.NET and BDP drivers
• SQL-92 entry-level compliance
• When running locally, can run in-process (remote is TCP/IP)
• Transaction support
• Log-based, crash recovery, rollback
• Row-level locking (plus table locking if you want it)
• Support for read-only transactions
• High-availability support (automatic and manual failover, incremental backup)
• Disaster recovery
• Stored procs, user-defined functions, triggers are coded in .NET
• Direct access to transactional context (you're running in-process on the server)
• Managed code protects the database kernel
• Single DB kernel for multiple editions
• A lot of vendors prefer to have a "server kernel" and a "micro-kernel" that aren't quite compatible in one way or another
• NDataStore doesn't; local, server, and high-reliability server all have the same disk structure, identical protocol, same transactiton management, same SQL, etc.
• All this in a single, 1.1 MB DLL
• That's for ADO.NET. If you want BDP, there are additional DLLs.
• If you want to do client/server, there's a client assembly available that's even smaller.
• Performance: Managed code doesn't make it slower.
• 64-bit support
• Licensing: Same as JDataStore ($60/seat for desktop version; $500/server for normal server; $1000/server for high-reliability server)
• Faster than mySQL in most benchmarks
• Note that mySQL does not support disaster recovery (doesn't force writes to flush to disk immediately, so a commit isn't really a commit), and NDataStore is still faster in several benchmarks
• Obviously, these are vendor benchmarks, so salt grains are required
• Single-file data store
• Zero-admin database: keeps transaction logs only as long as needed (no need to truncate or anything messy like that)
• Next steps:
• Apply for NDataStore field test (drop off a business card, or e-mail ggoldfield at borland dot com)
• Will need to sign an NDA, so you may not see me blogging about it :-(
• Interesting note: They actually maintain a single Java codebase, and run a tool to translate into C# with every build!
• 95% of code is shared
• Other 5% is .NET platform support (like ADO.NET), and written in C#
• No Delphi/Win32 client yet, but they've broken ground on this and are evaluating it

Sigh. If only they'd had this on the market a month ago. The folks back home (especially John and Jeff) will know what I mean.

posted on Monday, September 13, 2004 2:32 PM

3.8. Refactoring with Jim Cooper

Jim McKeeth

Jim Cooper of Tabdee and Falafel Software presented Introduction to Refactoring. Jim is a great speaker. It is understandable why his More Design Patterns in Delphi was so full. If you want to know more about refactoring, then get Martin Fowler's Refactoring: Improving the Design of Existing Code

Refactoring is changing code after it already works. It is a series of small steps to minimize bugs. Should use unit tests to verify you don't break it. Refactoring does not change the behavior or add new features.

Code is not for computers to read, it is for programmers to read. Most programs spend 90% of their time in maintenance mode - refactoring makes code easier to maintain. Since the code is easier to read, bugs are easier to find. In the long term it is faster, short term it will take longer. Reduces chaos in long-lived code. Fowler formalizes and names the best practices of refactoring.

Opportunities for Refactoring

• When adding functionality - makes adding new features easier, but keep refactoring separate from changes.
• When fixing a bug
• During a code review
• Refactoring does take time though
• May need to sneak it past managers at first
• Eventually you will refactor as you go and will not be separating it.

Points to Note

• Refactoring is typically based on OO
• More atomic then patterns, but may use patterns
• Most don't concern interfaces, but some may work with them
• Many refactorings include other refactorings, or one is required before the other can be applied.
• Some are opposites (extract method, inline method)

Thoughts on Refactoring: Most successful applications spend most of their time in maintenance mode, where you are fixing minor bugs or making other minor changes. If the application has been properly refactored then these small changes take very little time. Otherwise these changes are very expensive. Refactoring pays for itself in the long run if your application has any sort of life span. Refactoring doesn't mean the code was written wrong to begin with either.

posted by Jim at 9/19/2004 10:53:33 PM

3.9. What's New in the Delphi Compiler

3.9.1. What is new in the Delphi Compiler - Danny Thorpe

Robert Love

The following is my personal notes on new languages features, it is possible these are not exact.

For In Support

Delphi now supports For in loops, this is similar to the for each that is found in C#, this information is also found in Danny's Blog.

For element in collection do statement;

Basically you can do things like this
var
SA : Array of String;
S : String;
begin
For S in SA do
begin
ShowMessage(S);
end;
end;

Key Points of For In

• Read Only (you can not modify the element)
• Compiler can optimize the loop
• Available on both Win32 and .Net

Collection needs to have one of the following to work

• Implements IEnumerable(.NET) Interface
• public function GetEnumerator
• Compiler recognized primitive data types
• Arrays
• Sets
• Strings
  

Multiunit Namespaces

Goal: Support placement of Delphi Symbols into a specific .NET namespace while preserving unit make logic and syntax and package support.

• An assembly can contain classes that contribute to multiple Namespaces.
• Multiple assemblies may contribute to a given namespace
• There is no relationship between the assembly filename and Namespaces with in it (!!)
• When source uses a namespace, the compilers looks at the ALL of the Assemblies that contribute to that namespace.

Basically Namespaces relationship to Assemblies is a many to many relationship.

Delphi8 Solution

Unit name = .Net namespace (This has several problems which diamondback addresses)

Diamondback Solution

Dotted unit name: (Borland.Vcl.Classes)

• Right most name dropped
• Left remainder is the .NET namespace

You can now use the following in you uses

usesBorland.VCL.Classes;

Works as it always has, but only provides only symbols in Classes.

usesBorland.VCL;

Works only with Packages Fails when linking against source.

usesBorland.Vcl.*;

Works with Source Code as well as with packages, but it will not execute initialization sections of all units in the namespace. It will only execute the initialization sections if you actually use a symbol from that unit.

So where does the unit global variable and procedures go?

Namespace.Units.UnitName.Global

Also the.NET framework does not support constant data, it must be initialized in code, Delphi solves this problem by setting all of the data global data in the .Global . constructor.

Function Inlining

New .inline . directive, looks like a calling convention

procedure foo(I : Integer); inline;

Rules:

• inline directive is a suggestion; compiler may choose not to inline depending on the call site complexity
• Function body must be seen (top-down) before calls to the function can be inlined.
• Circular unit references defeat inline (See #2)
• ASM routines can not be inlined.
• Inlined code is spliced into the call site node tree prior to optimization - so, inlined code will participate in optimization at each call site.
• Inlinable code has limited access to private or protected symbols

Why?

• Faster Code

Why Not?

• Code Bloat
• Creates hidden temps, increase register pressure -> could hurt performance
• Always generates the real method.

Always messure the benefit of inlining!!

{$INLINE ON|OFF|AUTO}

Default is ON

Auto is not recommend, as it has both.

Misc Changes

MOVZX in code gen

• instead of XOR reg, reg / mov
• Favors P4/PE CPU - no prefiex opcode penatlty

Unicode Identifers, not supported in published sections

Improved Overload Discrimination, specically all of the different string types.

Forward declare Records are supported (.NET Only)

Future Directions (After Diamond Back)

Generics (Parameterized Types!)

Support for .NET 2.0

posted on Monday, September 13, 2004 1:39 PM

3.9.2. Danny's "What's New in the Diamondback Compiler" session

Joe White

Covering Danny Thorpe's session about what's new in the Diamondback compiler.

I've already posted several times about what's new in Diamondback. I won't duplicate any of that information here. And Danny was only talking about the compiler. Not about refactoring, not about databases, not about ASP.NET, not about ECO, not about VCL. Just the compiler.

Therefore, this is going to be a long post.

(Also, be sure to see my next blog post, with stuff Danny didn't say during the session. In particular, when are some of the other Delphi/.NET language features coming to Win32?)

For..in

• Loops over the elements of a collection, without actually requiring you to care about indexing into the collection
  
• When is it useful?
• When you don't care about the index, but just want the elements
• When you don't want to do an indexed loop because getting a count and/or doing random access is expensive (linked lists, database tables)
• Danny gave the example of asynchronous retrieval (a background thread is going out and getting the next element before you ask for it), which doesn't work so well with array indexes
• Unordered / non-indexed data (sets, hashtables)
• You should think of the returned data as read-only. Do not change the collection while iterating. (You can change properties on the object you got, but don't try to replace the object in the collection)
• Modifying the underlying collection should cause the enumerator to throw an exception the next time you call MoveNext. (So don't modify the collection while you're iterating!)
• Win32 implementation may allow writeback someday, but it might be full of gotchas. Assume that you should never modify the collection while you're iterating it.
• Because you treat the data as read-only (you are treating the data as read-only, right?), an enumerator should give you a stable view of the data.
• That means that, if you call Reset on the enumerator, and enumerate a second time, you should get the same data.
• Not guaranteed to be in the same order the second time, though.
• This is the theory. In reality, things like databases may not guarantee a consistent view, for performance reasons (because doing a read-only transaction might be cost-prohibitive). But if they did offer a consistent view, wouldn't that be nice?
• Syntax: for MyObject in MyCollection do { statement };
• Why not foreach?
• Because Danny was reluctant to add a new keyword
• Besides, should it have been 'foreach' or 'for each'?
• As a mathematician, Danny asked, "Wouldn't 'for all' be better?"
• So, no new keywords for this.
• Supported in both Win32 and .NET
• .NET uses IEnumerable if it's there, otherwise looks for the code pattern
• Win32 only supports the code pattern (probably because interfaces carry all that reference-counting baggage)
• The collection is held in a temporary variable.
• So, if you did forMyRecord in LoadCollectionFromDatabase do, you'd still be fast, because LoadCollectionFromDatabase would only be called once.
• Much like the way the for loop already caches its maximum value.
• Collection must fit one of these:
• Implement IEnumerable (.NET only, for now)
• Have a method called GetEnumerator
• Be an array, set, or string (or enumeration? Danny didn't remember for sure)
• Mechanics: (very familiar if you already know how C# does foreach)
• GetEnumerator returns an enumerator object, with MoveNext and Reset methods and a Current property
• You start with no current element (on a "crack", per Danny) and must call MoveNext to make the first element current
• MoveNext returns False when there are no more elements (if the collection is empty, it returns False the first time you call it)
• Reset rewinds the collection to the beginning. for..in does not call Reset.
• The enumerator is freed automatically at the end of the loop (inside a finally block).
• As I mentioned before, many classes in the VCL will support for..in.
• Not all, because when generics come out, they'll all be generics and it will only need to be implemented once
• TList has TListEnumerator, even in .NET (and even though TList is just a thin wrapper around ArrayList), simply because Win32 does need TListEnumerator. (It's there as a placeholder for code compatibility between Win32 and .NET, for code that uses the enumerator directly instead of using for..in)

Multi-unit namespaces

• Goal: Put symbols into a specific namespace while preserving unit make logic (which works by having a relationship between the unit name and the file on disk) and the syntax and the package support
• Relationship between assemblies and namespaces is many-to-many
• There is no relationship between the namespace and the file on disk
• uses Namespace; always refers to a namespace, never to a filename
• In Delphi 8: (the old way)
• Unit name = .NET namespace. This works as an interim solution, let's get it shipped.
• Problem: Exposes structure to the world. Component and library authors want to split code into multiple files, but that's a pain for their customers.
• More segregated than most .NET namespaces
• Can't inject code into a namespace you don't control (not that this was necessarily recommended practice to begin with)
• Diamondback: (the new way)
• unit Borland.Vcl.Classes;
• Rightmost segment is dropped. Types in this unit end up in namespace Borland.Vcl. (Borland.Vcl.TList)
• 'Classes' is still there behind the scenes (buried in the metadata), but it's not in the C# programmers' face
• uses Borland.Vcl.Classes;
• Compiler can find file on disk by appending '.pas'.
• Compiler can also find this unit within a package, and only pulls symbols for that single unit.
• This is using a unit, not a namespace.
• uses Borland.Vcl;
• This is using a namespace.
• Only works for code that's already compiled into an assembly. Cannot work for static linking (because there's no way to find the .pas file).
• Wide open; pulls in everything in the namespace, not just one unit.
• uses Borland.Vcl.*;
• This is either using a namespace, or using multiple units specified by a filespec. They amount to the same thing.
• Works against code in packages, and against source/dcus.
• Be careful. If you're going against source, this loads a lot of symbols from disk. (Compilation will be slow.)
• The smart linker will be even smarter for this. If a unit is dragged in by the wildcard, but you don't ever reference any of its types, then its initialization section will not be compiled into the EXE.
• This is here for completeness. Danny doesn't recommend using it normally.
• Danny didn't talk about this, but I imagine it would be a bad idea for Borland.Vcl.Classes.pas to say using Borland.Vcl.*;
• Globals (global procedures/functions, global constants, global variables) are as discussed in my earlier post: Borland.Vcl.Classes.MyGlobal becomes Borland.Vcl.Units.Classes.MyGlobal.
• The 'Units' is stuck in there because Delphi already allows a global named 'Classes' inside the unit named 'Classes'. (News to me! I thought that was a compiler error for duplicate identifier.) To avoid breaking it, they stuck an extra level in there.
• Simple unit names (no dots in the filename) are an exception to this rule. When the rightmost segment is in fact the only segment, it's not dropped.
• But if the project has a default namespace, it's considered part of the filename.
• So if the default namespace is Borland.Vcl, and the file is Classes.pas, then the "fully-qualified filename" (I'm not sure if this is Danny's terminology) is considered to be Borland.Vcl.Classes.pas, so the Classes is dropped.
  

A couple of interesting digressions

• Arrays in .NET can't be preinitialized, so if you have a global const array, it's actually initialized in code in the unit's class constructor (I'll have to reread the IL book . I know there is global data, since that's where strings are stored, but evidently it can't be used for arrays)
• Note on unit initialization sections: If you have circular unit dependencies, the initialization order may not be the same between Win32 and .NET. This is because, when unit A touches something inside unit B, unit B's class constructor will fire immediately in .NET, whereas in Win32 the initialization section might not fire until later.

Function inlining

• Involves persisting the compiler's node tree to the .dcu. Not been done before.
• Can produce significant speed boost in certain cases
• Caution: Code bloat risk!
• Not quite like C macros, because these aren't textual replacements . instead, it grafts nodes into the syntax tree (it's after parsing, not before)
• Works for most anything: procedures, functions, methods, and local procedures
• 'inline;' directive, looks like a calling convention
• Didn't Turbo Pascal have this a long time ago? Maybe it was just for assembler...
• Works for both Win32 and .NET (and may beat the JIT compiler in some cases, since the JITter goes for fast optimizations and low impact)
• The 'inline' directive is just a suggestion to the compiler. The compiler can disregard it if it thinks you're wrong or stupid.
• Could decide it would make the call site too complex (by needing too many temps and blowing your registers)
• The same procedure may be inlined at some call sites and not others
• This is still a top-down compiler. It must see the body of the inline procedure before it's used.
• In some cases with circular unit references, the compiler disables inlining on purpose.
• Doesn't work for procedures with an asm body, because that doesn't emit compiler tree nodes
• Spliced into node tree before optimization
• Generates temps for stuff that's passed into the procedure
• Then probably optimizes those temps right back out
• Restrictions on inlining stuff that access class privates
• Hard and fast rule in .NET: Can't inline these into another class
• May relax this rule in Win32 code, post-Diamondback
• Best practices:
• Use only for very small functions
• Always test performance and measure the benefit . don't assume it will speed up your code. It may slow it down!
• Caveats:
• Hidden temps; burns registers and stack
• Can actually hurt performance
• Causes unit dependency brittleness: users depend not just on your interface, but also your implementation. May not matter much for our code, but for this reason, expect Borland to be very conservative about using inline within the RTL and VCL!
• Since the procedure isn't always inlined, the compiler actually does emit a "real" procedure body as well
• @ operator returns this
• Presumably the smart linker is vigilant, and if every call is inlined, the real body will be eliminated
• {$INLINE ON/AUTO/OFF} directive
• Affects the call site
• AUTO = compiler picks "small routines" to inline. Per Danny, this option is "scary" and will never be the default.

Miscellaneous new features

• MOVZX (Optimization for P4/PIII processors. Will cause smaller/maybe-slightly-faster code on newer processors, at the expense of running slightly slower on older processors)
• UTF8 and UCS2 source for both Win32 and .NET
• Danny, weren't you going to show some amusing examples of this?
• No Unicode allowed in published properties or methods (I think this restriction is Win32-only)
• Improved overload discrimination (can overload on 'type of' types)
• Forward declarations for record types (.NET only)

Coming in Diamondback+1

• Whidbey support (well, yeah, you can compile against Whidbey in D8, but you can't consume generics so you're really a second-class citizen)
• Generics (for .NET; see below)
• May do something along the lines of partial classes
• Records with methods for Win32?
• (Also see my next blog post)

posted on Monday, September 13, 2004 6:06 PM

3.9.3. What *wasn't* in Danny's Diamondback session

Joe White

Stuff that came up after Danny's talk (which I briefly summarized here). Even those of you who were at the talk didn't hear this stuff yet. (Well, except for Allen, but I suspect he already knew all of this anyway.)

Delphifor Mac?

Now, don't get your hopes up. There is no official word on this yet. (It may be worth noting that this is not an official "no".)

Yes, you can get partway there with Mono, but there's not much there for GUI. However, when someone was asking Danny about this after the session, he pointed out that Diamondback will be a multi-personality IDE (with the three personalities out of the box . Delphi/Win32, Delphi/.NET, and C#/.NET). And personalities will be part of the Open Tools API. (Not sure if that'll be totally cleaned up for Diamondback, but it's there.) Open Personality API?

So, whether Borland writes a Mac personality or not (and mum's the word on that so far, so you can still hold out hope), somebody else might be able to. This is a pretty darned intriguing concept, I think.

The features are coming! The features are coming!

I spent a while grilling Danny about what will be in Diamondback for Win32, and what will sneak in later. Here are the results. (Tabular format makes the holes a little more glaring, doesn't it? Still, this is good stuff to hear word on...)

Feature	Diamondback	Diamondback+1 (Whidbeyish)
'strict private' and 'strict protected' in Win32	Yes
'static' keyword in Win32	No	Forgot to ask
Class constructors in Win32	No	Forgot to ask
Nested classes in Win32	Yes [Note 1]
Records with methods in Win32	No	Yes [Note 2]
Operator overloading in Win32	No	Yes [Note 3]
Custom attributes in Win32	No	Forgot to ask
Generics in Win32	No	Researching
Multicast delegates in Win32	No	Researching

Note 1: Yes, they'll be there, but you won't be able to use them in published sections because RTTI won't be able to cope with them.

Note 2: Records with methods will be there primarily because they're a prerequisite for operator overloading.

Note 3: Will only be supported for record types.

Usual disclaimers about forward-looking statements, but if Danny thinks it's going to be in a release, I'd say the odds are pretty darned good...

posted on Monday, September 13, 2004 6:14 PM

3.10. DiamondBack Preview

3.10.1. DiamondBack preview - tonight session

Serge Dosyukov

I do not want to compite with Nick
Check his blog...

But I would say - congratiulations to him for getting "Spirit of the Borland" award

And small word for Kylix community by Borland - "Kylix community project"
See for more information - Kylix alive and has a future

Also, DiamondBack installs !!! ;o)
It includes almost everything for BDS (you never know what will make in final release)
It has C#, D32, D.net

posted by Serge at 8:24 PM

3.10.2. Live From the Diamondback Preview!

Nick Hodges

We are live a the the Diamondback Preview!

Michael Swindell just announce the Kylix Community program which will be updating the Kylix CLX library, etc. Sounds pretty good.

Michael just announce the 2004 Spirit of Delphi award and the winner is.... me! I am totally humbled and honored. Thanks to Borland and everyone for thinking of me. I really appreciate it. Seriously, that means a lot. Thank you. I'm really humbled and honored.

Michael is now talking about the stuff in Diamondback.

• Refactoring, ECO for ASP.NET
• New ASP.NET Web Controls
• DBWeb controls are ECO enabled.
• New HTML designer features.
• dbGo for .Net
• Delphi Advantage for ADO.NET
• Create tables, edit tables, etc in the Data Explorer
• Team ALM productivity
• Fully integrated StarTeam into the IDE

Michael is bringing up Danny to do the compiler/language stuff.

Danny's Stuff:

• Function inlining to improve performance.
• Can do things above and beyond what the .Net JITer does
• Diamondback now supports multi-unit namespaces.
• There is the for..in language contruct (Equal to the foreach in C#)

Allen Bauer is now at the podium:

• He's showing how the VCL.NET designer can be the good old fashioned floating designer that we all know and love and how the designer works just like we remember.
• Allen's pointing out that they have .ripped off . a bunch of stuff from JBuilder. For instance, SyncEdit. It allows you to select a bunch of code, and change all the common symbols in the code, i.e. you make a change in one place, and all the symbols are change where you selected.
• He's showing the History function, which is sort of like a simple, local version control system. You can save as many copies of of a file as you need on disk, and the IDE will manage that for you, including source code diffs and what not. Very cool.

Now Ramesh is up to show the ADO.NET/BDP improvements.

• Designer enhancements: Select StoredProcedures, automatic StoredProcedure parameter population, Table mapping support.
• You can do schema/table creation in the IDE, copy table data from one location to another with bdpCopy, you can edit/alter tables and views as well, right from the DataExplorer
• There's a new component called the DataHub that appears to aggregate data from multiple sources, and there is a DataSync component that will manage all the updates for you. It's a conduit between the dataset and your changes to the data.

Next up is Chris Hesik to do debugging stuff:

• Chris was in the hospital and came in to demo for us. What a trooper!
• The biggest feature was to meld the Win32 and .Net debuggers together so that you can debug both together.
• He's got a project group with a Delphi for .Net, Delphi for Win32, and C# projects. He's setting a breakpoint in each project, and is hitting each of the breakpoints, all at the same time. He's debugging a Win32 and a .Net process at the same time.
• Each of the items in the stack frame now have local variable information. If you select an item in the stack view, you get its local variable
• Breakpoint view is nicer -- can enable/disable breakpoint with checkboxes and inplace editing for variable breakpoints.
• There is IL and native assembly in the CPU view
• You have the choice to break or not break on a given exception. You can even ignore an exception, and the next time that exception is raised, it will continue to be ignored. That's a very nice feature.

Next up are the ECO guys, including Malcom Groves:

• You know, I don't totally understand the ECO stuff, but it sure looks cool. I understand the big picture - that you can design classes that are persistent -- but exactly how that works in ECO isn't clear to me...
• They are now .back-tracking . the Northwind Database into ECO. That's pretty cool.

Mark Edington is up next. (Have I mentioned that Mark is just a really smart, really nice guy?) He's talking about Unit Testing. This is pretty hot stuff, folks. There are wizards that will automatically build test cases for your classes. It's all done automatically, so all you have to do is write the actual tests and nothing more. Very, very nice. If you aren't doing Unit Testing, you need to start doing it. My only beef? It defaults to using _Result as the result variable for a test. Doesn't everyone know that underscores are the Spawn of Satan?

John Sileski is going to demo StarTeam integration. I personally am pretty excited about this. I love StarTeam, and am really looking forward to a tight integration between the IDE and StarTeam.

Jim Tierney is up showing the new Web Deployment Manager. This is a really neat feature, and very useful. You can easily deploy an ASP.NET application to any network or FTP location. In addition, the ASP.NET Project Manager will show all the files in the directory of a project, as ASP.NET projects are very file based. It's a nice feature.

Finally, Corbin Dunn is up. Corbin is another really, really nice, super smart guy.

• He's showing off refactoring. This is really nice, too, folks. You can extract methods, rename variables (across the entire project), extract resourcestrings, automatically declare variables, and find the unit of a given declaration and add it to your uses clause.
• He is showing HelpInsight, where a .help hint . pops up for identifiers when you hover the mouse over an identifier

That's it. If you aren't fired up for Diamondback, I personally think you don't have a pulse. ;-)

And here's why you should have come to Borcon -- they are giving all of us a CD with the Preview version of Diamondback on it. Don't you wish you were here? ;-)

posted on Monday, September 13, 2004 8:46 PM

3.10.3. Diamondback Preview Session

Robert Love

I am now in the session room, and it looks like it might be standing room only once it fills out.... Yep it is standing room only.

Announcement:

Kylix Community Project - Admin Team: Borland Chad Hower, Andreas Hausladen, and Olaf Monien

This is to Improve the Clx Library

Spirit of DelphiAward 2004 Award goes too... Nick Hodges This is very well deserved.

Several members of the Delphi team are coming up and showing some of the features in Diamond Back

Danny Thorpe (Compiler Enhancements)

• Compiler Inlining
• Multiunit Namespaces
• For In

Allen Bauer (IDE Enhancements)

• Floating Designer!
• Sync Edit
• History Window with Diff Viewer
  

Ramesh (ADO.NET/BDP )

BDP Designer Enhancements

• Drop down list for stored procedures
• Automatic parameter population
• Drop down for SchemaName
• TableMapping Support

Meta Data Service

• Create,Drop: Table View, Indexes
• Alter Table
• Data Migration
• BdpCopyTable

DataHub and DataSync able to resolve database, Data can come from multiple database sources into a single datasource

RemoteConnection and RemoteServer are new components that make it easy to remote datasets.

Chris Hesik (Debugging Features)

• Able to run and debug multiple applications at the same time, this includes project targeting different platforms
• Win32: Local Variables for each stack frame
• AppDomains in Module View
• Breakpoint view has easy check box enable/disable and tool bars.
• IL Disassembly in the CPU View
• Exception Dialog - Break and Continue Button and a Check Box to ignore the exception type.

Hendrik and Malcom (ECO)

• Design Surface to Define Classes.
• Showed how they work with ADO.NET
• How you can change and object and it auto update the database.
• Showed how use the an existing database. The reversed the SQL Server Northwind Database

Mark Edington

• Unit Testing
• DUnit and NUnit

The battery going out will update the rest later...

posted on Monday, September 13, 2004 5:59 PM

3.10.4. Diamondback Debugging

Craig Stuntz

I haven't written about Diamondback as much as I'd planned since others are doing such a good job of it. But one demo which I thought was neat was concurrently debugging Win32 and .NET apps.

the debugger is context-aware and will switch back and forth between Win32 and .NET modes as required. So you can create a project group with both .NET and Win32 projects and set breakpoints in both of them. When they trip, the debugger will change modes for the current frame. Should be very useful for debugging applications which host the framework, ActiveX controls, and unmanaged exports in Delphi for .NET apps.

posted on Tuesday, September 14, 2004 3:56 PM

4. Borcon Tuesday Sessions and Events

4.1. RemObjects at BorCon

Serge Dosyukov

Alessandro Federici had BOF session today about RemObjects Framework and Chrome.
Borland wasn't be able to manage to put his name on BC Update flyer for some reason but people did come and able to see in action an elegant solution provided by RemObjects for Delphi developers. Visit www.remobjects.com and see this great library.

As a second part of presentation we saw Chrome

Chrome is RemObjects' Next Generation Object Pascal language for the .NET and Mono Platforms. While implementing a language that stays true to the beauty and elegance of Object Pascal, Chrome adds useful design elements from other languages such as C#, Java and Eiffel, and it introduces its own language innovations.
Use Chrome to write fully managed native .NET applications for the Microsoft .NET Framework, the Compact Framework or the Mono Platform, and develop your applications inside the well known Visual Studio .NET IDE

I really would like to see evolution of this product. If you are open for changes in Object Pascal language then it will worth to look at it.
Alessandro and team is introducing a new language which is similar to OP (about 80%) but added few extensions to it (aside from one related to .Net framework).
For now it is just language (no designer), but you can code in it for .Net. And... it compiles and run!!!! And it is in Visual Studio, it consumes it, so all features of VS.Net available for developers.

Using Pascal language for last 15 years, I really looking forward what this project became over time. Great staf.

posted by Serge at2:46 PM

4.2. Overview of InterBase 7.5

Craig Stuntz

Charlie Caro gave a preview of new features in IB 7.5, a free update for IB 7 customers.

When?

Goal is to ship with Diamondback.

Features and Goals of Release

• SQL Functionality
• Global temporary tables - like a regular table but data goes away at end of transaction or attachment. Each attachent sees its own data only. Can be indexed. SQL Standard doesn't allow constraints between regular and temporary tables.
• CASE, COALESCE, NULLIF
• SQL Performance
• Memory management algorithms changed to better fit a server architecture. SMP support exploited to increase allocation speed.
• Allows memory to be reclaimed and returned to the OS more regularly. Stored procedure clones, internal queries, and the like can't hold memory for extended periods of time anymore. By default done every five minutes, but can be done manually via performance monitoring or you can change the default.
• Sort buffer allocations optimized to reduce page faults.
• Page size limit increased to 16K, page buffer limit increased to 131,000 -- allows use of full 2GB address space available to process. Don't combine these two maximum values as IB does need some memory for other things!
• Page cache will be dynamically expanded for increaed client loads.
• I/O strategies: Two new alternatives to forced writes or asynchronous writes:
• Asynchronous writes with periodic flush -- IB guarantees a write cache flush every so often, can be triggered manually or scheduled. Pages written in order of optimal performance, with intra-thread coordination.
• "Group commit" (careful writes done in background thread).
• Database linger prevents server from freeing up memory when all attachments detatch. Good for cases where users frequently connect and disconnect, like a web application. Can be configured with the interval of your choice. Also allows garbage collection or sweep to continue.
• Server performance -- SMP
• Atom synchronization improved; prevents excessive thread switching for high-frequency, short locks. Means IB can use maximum CPU power.
• Improved SMP performance by changing page latches to reduce need for multithreaded synchronization. Long-running procs and queries should see 100% - 300% improvement; sweep can be three times faster.
• JDBC driver improved -- supports savepoints, remote protocol improved.
• Security
• Embedded user authentication allows storage of user data in DB file instead of central admin.ib file. Can maintain user accounts with DDL-like commands. Can set default ROLE (for embedded users). Can create a SYSDBA user (with usual privileges) but it isn't required. Users can change their own passwords.
• Deployment
• Can run multiple versions of IB on a single server machine (as long as at least one of them is 7.5 or higher).
• Ease of use
• Server-side DB aliases. Defined in admin.ib table DB_ALIAS.
• Performance monitoring improvements.

posted on Tuesday, September 14, 2004 8:38 PM

4.3. Borcon Day 3 - Tuesday

Euan Garden.

Luckily my alarm call actually worked this morning so I managed to make it to my session on time, no demo dramas this year(last year I had to rebuild my machine starting on the morning of my session). I managed to get through all my slides bar 3 and 1 of my demos, which I was pretty happy with. It was really a 100mph session with a ton of content, I checked out the feedback forms and most people were happy but the did complain there was not enough time. I'll try and prune it back if we do it again next year, all feedback gratefully received for next years version! The agenda is below so you can see what I covered:

• SQL Server 2005 Overview
• SQL Server Express Edition
• Data Access
• .Net Integration
• Web Services Integration
• T-SQL
• XML
• Security
• Service Broker

After my session I sat in on Donald Farmer's session on DTS and Reporting Services, Donald did his usual awesome job, including writing a report designer in Delphi for .Net. He then showed how DTS can consume RSS feeds and used Text Data Mining to decide on .interesting . articles.

I then spent lunch working on the booth and giving out the SQL Server 2005 Beta 2 resource kits which included B2, Hands on Labs, Web Casts and a bunch of other useful stuff. We finally ran out of SQL Server T-Shirts as well, but we gave out some others at the party later. I bumped into BradA as he was arriving, he was sitting in on some of the sessions as well as answering questions in the booth before he headed out to a user group meeting and doing his session at 8 on Wed morning. We obviously upset the same person to get stuck with 8am sessions!

After lunch I headed back to the hotel for a quick snooze, another conclusion that I am getting old, I can't handle the late nights(and no alchohol was involved!) at conferences any more!

This evening was the party sponsored by MS at the San Jose Tech Museum, this is the same place as last year so I managed to find the food MUCH faster than I did last year. Spent time chatting with some of the Falafels and some of the other MS folks. DavidI came over to chat for a while and was telling us amusing stories from previous Borcons. He has been to the odd one or 2, overall it was a good night and there were more free t-shirts on the way out. Oh and if you were the guy I saw dipping twinkies in the chocolate sauce on the desert table, I really hope you get help for the carb addiction!

posted on Wednesday, September 15, 2004 6:57 PM

4.4. Creating Custom ASP.NET Components with Nick Hodges

Jim McKeeth

Nick Hodges of Lemanix (The #1 Borland Partner in Minnesota) is covering ASP.NET component building. He will be using Diamondback and Delphi.

First a couple panoramic shots:

This one is from the back of the room. On the left you can see the boom camera they used in the keynotes and general sessions. On the right is one of the many stationary cameras.

This one is from up front where I ended up sitting. Notice the tables they had set up this year is most all the halls. It made taking notes very nice.

UPDATE: These photos are from Nick's ASP.NET Development Strategies, not Creating Custom ASP.NET components. Same speaker, different location and time. This pictures don't do Nick justice. He looked like a rock star up there. When he finished his session they turned on the lights and the lightening video behind him.

Topics to be covered:

• Why build controls?
• User Controls
• Rendering
• Web Controls
• Persistence in Properties
• Block Types
• Div
• Span
• P (Paragraph)
• Postback Management
• Lifecycle of a control
• Client-side Javascripting
• Composite Controls
• A control made of multiple controls
• Complex Properties
• Inner Properties
• State Management of Complex Properties
• Template Controls
• HTTP Handlers

User Controls

User Controls are "page chunks" that just provide a portion of the page. Typically they contain common headers, footers, etc. Need to have the "*.ascx" extension. Behind the HTML there is also code-behind code.

Server Controls

They abstract the browser so the correct code is rendered for the current client. They encapsulate features and behavior and maintain state. Server Controls are configurable at design-time like components. Server controls are easier to share then user controls.

System.Web.UI.Control is the base class to descend from. Must have a parameter-less constructor. All properties must have get_ and set_ assessors.

Any HTML you want to output must be outputted in the Render method. Simply place the control in an assembly (or package) and install it into the IDE. It is worth noting that the control does not by default have any style support.

For a web control you override RenderContents method. The Render method handles the block tags (P, SPAN, DIV, etc.)

Composite Controls

Composite controls are controls that contain multiple child-controls. This is different then User Controls because all the controls are generated in code with no visual design. Must implement INamingContainer (with no methods) to indicate that it will name all child controls based on the name of the parent control to prevent collision with other controls on the page. All assessors must call EnsureChildContols before accessing the properties of the child controls. Composite controls must override render for customer rendering. If Render is not overridden then the child controls are streamed out one after the other. When overriding Render you can call AddAttributesToRender passing the Writer to automatically render the attributes of the parent control.

The Writer is an HTMLTextWriter class to facilitate the construction of HTML. Internally it uses StringBuilders and understands the concepts of opening and closing tags by calling RenderBeginTag and RenderEndTag. If you want to add attributes then you call AddAttributes before you call RenderBeginTag. To Render a child control call the RenderControl method of the child control, passing in the writer.

posted by Jim at 9/19/2004 07:12:57 PM

5. Borcon Closing Sessions

5.1. BorCon 2004 closing session

Serge Dosyukov

Session is started with digest of the moment from opening session. Then it is followed by introduction dance by dancing group which we saw sunday. Dale and David thanks support team, advisory board, speakers, TeamB and people who blog during conference. "Thank you" word to a sponsors

Then after some information discussion for BorCon attendees, John presents a new features of BDN web-site: new format (ASP.Net, Diamondback... some section are already moved some might moved as it go), new EventCentral.

Dale and David again point to a presentation of new Delphi 2005 version and encourage to go and evaluate product (D2005 preview), prepare yourself for official release.

Again Dale point at effort of Borland to go hand-by-hand with developers into a new era of Software Development and being with Borland all these years.

Then it is a time for Borland bucks drawing for prizes. Dale mentioned accident happened in past when Borland bucks did fell, almost, on gim and missed by inch. ;o)

My friend won one!!!! Congratulation.

Again some people was shot.

Then prizes again...

BorCon 2004 officially is closed.

PS. I will continue with this blog to give you more details on sessions I did attend.

posted by Serge at 2:44 PM

6. Resources

Other Borcon 2004 resources on the web:

• Marco Cantu http://www.marcocantu.com
• Paul Gustavson http://www.simventions.com/gustavson/
• Dr. Bob http://www.drbob42.com
• BDNTV http://bdn.borland.com/bdntv
• Borcon 2004 Wiki http://www.excastle.com/BorCon2004/wiki.pl