Borland Conference 2004 Blogs
Compiled by Erwien Saputra
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.
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
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
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
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
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.
posted on Saturday, September 11,
2004 10:29 AM
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
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
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
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
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
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
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
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
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:
Plus the annual tradition of Dr Bobs conference
report
posted on Tuesday, September 14, 2004 10:37 PM
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
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
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
Trainer of the Year
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 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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?
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
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
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
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
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
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
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
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
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
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
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
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:
