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.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.3.1. BorCon 2004 is opened - short.
2.3.3. Unleash the Power - From the BorCon Opening Session.
2.3.4. Opening session and 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.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.7.1. New Borland Product: 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.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.2. Overview of InterBase 7.5.
4.4. Creating Custom ASP.NET Components with Nick Hodges.
5.1. BorCon 2004 closing session.
1. Preconference
1.1. Tutorial Sessions - day 1 - extended and corrected
Serge Dosyukov
From a variety of sessions I .ve choose two:
- Microsoft .net Framework Security by Steve Teixeira
- XML in Microsoft .Net Framework by Robert Love
Bellow is a little about first
I think it was a great session. Yes, there is not enough time to cover .Net security in 4 hours, but Steve did great presentation.
He covered main aspects of incorporating security context into your application.
Next topics were included:
- set a security for your application code -at design time
- assemblies security settings . signing, security certificates, &
- cryptography in your applications
- security in ASP.Net applications
- ASP.Net authorization
What is good about all such sessions, it gives you an idea where to look and what to expect. It gives you a starting point from which you can elaborate and come with a solution you need.
Note You might be surprised, but you will see a lot of Diamondback (Delphi 9) or Delphi 8 during a sessions which are in any way related to .Net and require some code samples. Almost all demos are done within them . you can see C# or ASP.Net code, Delphi.Win32 or Delphi.Net. I think this is showing a big effort of Borland in promoting a new version of Delphi or Delphi in general. I will encourage you to look at these products today and as soon as it (Delphi 9) will be available for evaluation.
Second session by Robert. Great session! Tutorial provided a basic coverage of main elements on how XML is used throughout MS .Net Framework. All samples was done using Delphi for .Net (Delphi 2005 or Delphi 9.0, I really do not know what it will be at the end, I like 2005 better). Robert cover main aspects of use of XML from application: reading and writing from/in XML document, validation, and transformation. What I personally found handy . it is how any Delphi class can be easily serialized via XML by using XMLSerializer. It is easy and fully customizable. Great addition for Delphi component streaming.
posted by Serge at 2:39 PM
1.2. Get Ready for Microsoft .NET Framework 2.0
1.2.1. Live from Danny's Talk
Nick Hodges
Okay, folks, I am sitting here in a conference room with a couple of my TeamB mates. Danny Thorpe is standing on the podium getting ready to give a four hour tutorial on the topic of .Get Ready for Microsoft.Net 2.0 .. I think in the interest of being on the cutting edge, I am going to give a shot at live blogging his talk. How does that sound? We'll see how it goes, eh? I have a personal rule: If Danny's talking, I listen. And now you can virtually .listen . as well. Keep hitting refresh, as I'll be updating this all morning.
Things will be getting underway here in about 15 minutes.
Danny is talking on the new Dotnet framework, .Whidbey .. He specifically says he's not talking to the MS marketing slides, but to the technical end of things. (Not a surprise, as Danny doesn't suffer marketing well, I don't think....)
Danny is pointing out that Avalon will be available on XP eventually, as it has been decoupled from the release of Longhorn. Interesting.
Danny points out how there is a blurry line between what C# is and can do, and what the CLR/Platform does. As a Delphi developer, he's far more interested in the platform.
Driving Factors for 2.0
Improve Security -- MS did a complete audit of their codebase to improve security of the core infrastructure.
Improve .Host Control . -- i.e. improve the ability to host CLR-based assemblies.
Improve Performance and memory use.
Danny points out that 2.0 development is really being driven by Yukon/SQL Server -- that the needs of what they want to do with Yukon is what is driving the development of 2.0.
CLR Architectural Changes
Generic Types are probably the most significant change.
Large increases in CLR Host capabilities
64-bit platforms will be released only on the 2.0 platform, including Intel Itanium II, AMD64
Improved Compact Framework support -- less .Hackish . particularly for the design environments. Danny says that Borland is .very keen . to support the CF in Delphi, and they are continuing to work with MS to work this issue out.
C# Language Changes
Generic Types, Partial classes, Anonymous Methods, yield iterators
Danny points out again that there should be a clear difference between CLR features and C# features, but that the line is alway blurred, especially in the press. He is showing us an example of C# generics, and discusses how they can actually improve codegen and code savings. Danny says Delphi will implement the 2.0 generic model. Methods will be able to declare generic types as well. Danny says that the Delphi syntax will look almost the same as the C# syntax. Generics will allow things like generic TList implementations to manage specific types and reduce the amount of typecasting needed to manage lists of pointers, etc. This will be really cool I think.
Anonymous methods: I confess I can't understand exactly what this is. It seems like a different kind of polymorphism, where you can declare a method that will get .filled in later . sort of like an abstract method.
Partial Classes: You can split a class in half, with multiple source files implementing parts of classes. You'd then separate out machine generated code from user generated code. (Think of, say, the ugly .InitializeComponents . call that does what the DFM in Delphi does. That code would end up in a different file that would be .hidden . or whatever. Code folding apparently isn't good enough here. ;-) In other words, your event handler code would be in one file, and the changes made in the Winforms designer would get put into another file. Another good example is, say, an ActiveX generated unit that you might modify, and then lose your modifications when the file is regenerated. (Editors Note: This is the kind of thing I hate -- this is a lot of work just because C# has this crappy model and no DFM files.)
This also means that ASP.NET will have a sort of .code-beside . model, instead of .code-behind .. Partial classes will be used to augment your source. The ASP.NET framework will actually have total access to your classes, because they are declared as partial classes.
New Iterators: The ability to .yield . back in the middle of iteration to present data to the caller. Think about the ability to iterate over a dataset, with the iterator being able to return each row for modification.
VB.NET Language Changes
They will be able to access, but not define, generic types
Partial classes
Operator Overloading
XML DocGen
Edit and Continue Debugging (Yuk! Is it just me, or is this a catastrophically bad idea?)
I'm not going to bother talking about the C++ Language changes. I find .Managed C++ . to be one of the ugliest, silliest ideas in all of the programming world, so let's just pretend that it never happened, okay?
Danny is now entering into the Will DeWitt/Dennis Landi portion of the talk, and discussing the 64-bit end of the 2.0 framework.
- The JIT compiler will compile IL code to native 64 bit instructions for AMD64 and Itanium-2, but not Itanium-1
- Need to remember that SizeOf(Integer) <> SizeOf(Pointer)
- Can PInvoke into unmanaged Win64 code
- Will have IL Binary portability (i.e. you can take a binary from machine to machine, and 32-bit to 64-bit)
Danny's pointing out that Delphi will support the CF framework and the 2.0 Framework as soon as possible, but that they are in beta, and thus a real moving target. He points out that with the 1.0 framework, the metadata streaming was totally changed late in the beta, and something like that causes big problems for folks like Borland. They plan to do a Delphi release that will synchronize with the 2.0 framework when the 2.0 framework is released. Danny expects that to be .summerish . in 2005.
He's now talking about how generics might be implemented in the Win32 compiler. He thinks that they might be able to do it -- they have a plan. They'll implement it in .Net first, and then give it a look. It will probably be a sub-set of the .Net version, and not a complete implementation.
ASP.NET 2.0
- Declarative Databinding -- now you have to write code to do databinding. 2.0 will have declarative databinding. It's data-driven, but still some code.
- Provider Model -- drop a module in to do a specific service. For example, a login provider. There's canned stuff in the framework, but you can define your own. Another example -- credit card management, catalog management
- Web Parts -- Portal/personalization functionality. You can move stuff around, skin the colors, etc.
- Master Pages -- easily define a Master Page and a Theme for your application. Easily separate/decouple this from code. Themes will tie into the CSS stuff, allowing you to easily manage that for the user, or have the user manage it himself.
Okay, back from the break:
Yukon/SQL Server
- It will host CLR code in process, allowing you to build assemblies to do the storedproc thing instead of SQL
- Why? Gives Yukon lots of security and control over data access
- Won't even look at code that doesn't PEVerify
- You can define your own complex field types in your assemblies.
- Want to add flexibility and dynamic functionality and while at the same time providing security.
- Yukon is practically an operating system unto itself. Takes over CLR Memory allocation, CLR Exception Handling, and the CLR Security Model, Thread scheduling
- Yukon will inspect all managed code to ensure it can be executed. If you don't pass, you don't load.
- Will abort your code .at the slightest provocation .
- Yukon prefers that your code not have any global, static information/variables to prevent having interprocess communications. It prefers object instances and stack variables
- Yukon will require the 2.0 framework, and won't do 1.1 at all.
- This is definitely a move by MS to move into the Enterprise space. They definitely are targeting Orcacle here
- The Yukon team is pushing the CLR folks to be more scalable, secure etc. Danny notes that Yukon is having a real positive effect on the CLR
Compatibility with 1.1?
- Theory is that .Net will get rid of DLL hell. But this hasn't really been tested until there is a totally binary incompatible version of the framework out there. That's coming, though
- There should be very few source code incompatibilites. The 2.0 framework should have all the calls from 1.1. There may be side effects, however.
- 1.x and 2.0 should sit side-by-side on your machine.
- You might be able to use an app.config file to .float . a 1.1 binary up to bind against 2.0, but .caveat emptor .
- You can right now tinker around with the 2.0 platform if you rebuild the Delphi RTL to work agains the 2.0 framework if you rebuild the Delphi RTL using the command line compiler. The Delphi compiler can only compile against a given platform.
What does this all mean for you?
- Danny recommends that if you are starting a project today, you should work against 1.1, but keep an eye on 2.0. Obviously something like generics is going to change the way that you do things. Some of the interoperability rules change, for example. New stuff will change the way you debug, probably. Think about debugging a partial class, for example
- This is a 2.0 release, not a 1.0 release. .We are out of diapers .. This has gone through a lot of code review
- There will be application versioning concerns. You need to realize it is out there, and may affect your 1.1 apps, even though it isn't supposed to. ;-)
- Danny points out that 2.0 means a lot more to MS than it does to us. Yukon using 2.0 in a big way. It's MS's push into the enterprise space. Good for developers, because CLR gets stronger, more scalable. .Microsoft is betting the farm on 2.0 . says Danny.
posted on Saturday, September 11, 2004 9:27 AM
1.2.2. Delphi Syntax for Generics
Robert Love
I am sitting in Danny Thorpe's session on CLR 2.0, and did not want to wait to post this little tidbit. Mentioned that this would be in the product in 2005.
Delphi Syntax for Generic Types will be:
type
TFoo<T> = class
private
data1: T;
public
function SomMethod(param1: INteger; Param2 :T) : Integer;
end;
function TFoo<T>.SomeMethod(...);
begin
end;
var
Foo : TFoo<Integer>;
posted on Saturday, September 11, 2004 7:46 AM
1.2.3. 64 Bit Changes for the CLR
Robert Love
JIT compile IL to native 64 bit instructions, will be optimized to specific processor type.
Sizeof(Pointer) <> Sizeof(Integer)
IntPtr type 64 bits wide
P/Invoke only works into unmanaged Win64 code.
Delphi note:
Delphi 8 with Winform's work fine with no changes.
Delphi with VCL will need some changes. Specifically because THandle is declared as Cardinal (32bit) in many places and it's size changes. So this needs to be addressed before the VCL will work on 64bit.
posted on Saturday, September 11, 2004 8:46 AM
1.2.4. Danny's .NET 2.0 talk: Part One
Joe White
Covering Danny Thorpe's preconference tutorial on .NET 2.0. This is the first of two parts (I'm writing this during the break).
.NET 2.0 is a topic that's already been covered fairly exhaustively by Microsoft and others. And yet, I've already taken two and a half pages of notes.
Highlights so far:
- Diamondback will not have any of the new .NET 2.0 features. It will target .NET 1.1.
- The version after Diamondback will support .NET 2.0 new stuff, and will come out about the same time as Whidbey ("summerish" 2005).
- .NET 2.0 Delphi will support generics and type inferencing, and may even push the envelope.
- .NET 2.0 Delphi will probably have to support partial classes, because ASP.NET 2.0 requires them.
- Delphi generics may work on Win32, but will probably only work with interfaces and maybe classes.
More detailed notes follow. They may bore you.
- You can compile against .NET 2.0 today in Delphi 8. There's a compiler switch that lets you specify which runtime version to target.
- Danny is talking technical, not marketing. Microsoft is giving a .NET 2.0 presentation later in the conference, and they got in touch with Danny to ask if their content would overlap. He said no, that wouldn't be an issue.
- .NET 2.0 will be the first binary breaking change since .NET was released, and will really test Microsoft's versioning features.
- Features and schedule really driven by Yukon
- 64-bit stuff:
- MS will not release 64-bit support in anything earlier than .NET 2.0, even though they've got it working
- Itanium 2, but not Itanium 1 (MS jokes that they have the largest installation of Itanium 1 machines in the world, and they're not going to support it)
- Assembly needs extra header flags to run as 64-bit ("I actually tested this and I know what I'm doing" flags)
- Otherwise emulated (interpreted!) 32-bit mode
- Delphi will support 64-bit-capable .NET (i.e., it can set these header flags)
- P/Invoke will bind directly to 64-bit APIs. 32-bit WinAPIs will not even be accessible.
- Delphi will support generics in the 2005 timeframe
- Type inferencing: No coding done yet, but Danny doesn't anticipate problems
- Anticipates pushing the envelope
- Better constraint syntax (as opposed to C#'s "where" that looks like SQL)
- .NET lets you, and Delphi will let you, define both TList and TList in the same scope
- C# has a syntax ambiguity that Delphi will not:
class Boo { ... }C# has a devil of a time figuring out the difference between the last two lines, because when it's parsing the input, it doesn't know what the tokens mean. Delphi won't have that problem, because it knows that Boo is a class name and a is a local variable: there is no ambiguity.
void Foo(System.Type x) { ... }
void Goo(bool x) { ... }
Foo(Boo);
Goo(a < b); - Anonymous methods: Evaluating; don't know if Delphi will have
- Same for iterators
- Partial classes:
- ASP.NET 2.0 will use "code-beside" using partial classes (not code-behind as in 1.x)
- So Delphi will probably need partial classes; Danny thinks it can be done, even with top-down parser
- Syntax: won't call them "partial"
- Side note: VB.NET 2.0 won't be able to declare generic types!
- Side note: D8 already supports XML doc comments
- Edit & Continue: Last word was, can't edit currentscope, nor anything on stack! (makes it kinda useless, doesn't it?)
- C# won't have it
- Delphi will wait and see.
- ...oops, Danny's about to start again, I'll post more later.
posted on Saturday, September 11, 2004 10:29 AM
1.2.5. Danny's .NET 2.0 talk: Part Two
Joe White
Covering Danny Thorpe's preconference tutorial on .NET 2.0. This is the second of two parts (the first is here).
Nick was blogging Danny's talk during Danny's talk. Either he found an outlet, or his laptop has waaay better battery life than the one I've got. So his blog entry is also worth a read.
Okay, picking up more or less where I left off before the bio break:
- POGO (profiler-guided optimizations)
- Why it matters: 64-bit processors have a big penalty for branches (lookahead and all that). POGO tests the app under real use, and if one branch is called 10x more often than the other, it changes the emitted code to adapt. Might even move code around to keep the most-common stuff together.
- Will only be available for Managed C++ (it's not clear why)
- MS won't license it out, so Delphi is out of luck (and so is C#)
- Pointless side note: The Delphi/Win32 compiler has a NativeInt type. Don't use it. It's going away.
- Delphi for .NET will support 64-bit processors, but VCL for .NET does not
- In 64-bit, OS handles are 64-bit
- There's still some code in VCL that has them as Cardinal
- As part of the fix, compiler will probably add warnings if you try to assign a handle into a Cardinal or an Integer, so third-party code can be fixed easily
- .NET 2.0 will have TryParse methods (hooray!), because Yukon (a) doesn't like the overhead of exceptions, and (b) reserves the right to terminate running code if it throws any exceptions at all!
- Note about CLR hosting: Load the runtime once into your process, and it sticks
- So you'd better know which runtime version you want when you start up
- Other notes: Host can remap assembly bindings (ask for Studio -> remap to a request for a D8 assembly)
- In 2.0, memory allocations will go through the host first, then the OS (because Yukon is really its own OS: it allocates all available memory, sub-allocates it to the CLR, and uses everything that's left for various forms of caching)
- In 2.0, exceptions also go to the host first (because Yukon wants to be able to terminate immediately if certain bad exceptions happen)
- In 2.0, threading goes through the host (because Yukon doesn't use threads, it uses fibers)
- Diamondback = .NET 1.1
- There will be a 2.0 Delphi release in the Whidbey timeframe
- On generics and Win32:
- Reeeeally don't want to codegen Win32 code at runtime
- Generics may exist with restriction that T must be an interface (or maybe a class)
- Don't know whether generics will be in first 2.0 release
- The Whidbey-timeframe Delphi compiler may not support iterators or partial classes for Win32
- ASP.NET 2.0:
- Provider model: "I am your login genie . if you need login services, cookies, etc., come to me"
- Web Parts: customization a la My Yahoo!
- Master pages (hell, I was doing this back in 1.0, with a UserControl for the page header, another for the page footer, and a handler in Global.asax to insert them into every page)
- Editorial note: ASP.NET 2.0's code-beside model will make a lot of users very happy, because they'll no longer be forced to make all their fields protected (and get yelled at by FxCop).
- Yukon doesn't like static variables
- Each request should be isolated from the other requests
- Static variables also introduce opportunities for memory leaks
- Problem: all Delphi-generated code has static variables, because that's how class types are implemented
- Need to relax this rule in Yukon in order to use Delphi code
- Yukon will only support .NET 2.0, not 1.x (not surprising, given that most of 2.0 was a drive to make .NET meet the standard set by the Yukon team)
- Compact Framework in Diamondback
- It should work, but you may need to use the command-line compiler
- Unless a miracle occurs, there will be no designer, because MS's designer is still screwed up and not ready for release
- Delphi 8 won't work in CF because of the way Delphi tries to ensure deterministic unit initialization order (calls RunClassConstructor, which doesn't exist in CF)
- Diamondback will try to load that method, and if it doesn't exist, will still let the app run (but won't guarantee unit initialization order)
- As reported recently, .NET 1.1 SP1 breaks Delphi 8. Danny anticipates a fix by next week.
- mscoree.dll
- Every managed app has an unmanaged entry point that calls mscoree.dll, which looks at your EXE, loads the right CLR version, and sends you on your way
- There's only one version of mscoree.dll on your system at a time (not much other way for it to work)
- Bug to note: When you install .NET 2.0 beta, it overwrites mscoree.dll (no problem). When you uninstall, it does not put the old mscoree.dll back (problem).
- .dcpil, .dcuil files have references to the Framework, and are therefore not platform-portable. To use D8 with .NET 2.0, you first have to recompile the D8 RTL.
- GC note: Each thread has its own heap, so there's no thread contention for the heap. Interesting.
And there you have it. Much info, much trivia, and I didn't blog the stuff I wasn't interested in, but this should be of some interest to the folks back home. Share and Enjoy.
I have another three pages of notes about John Kaster's talk about Diamondback, but I'm going to go get some food, and blog about his stuff later. (I will write about it later; whether I blog about it tonight or tomorrow depends entirely on wirelessness.)
posted on Saturday, September 11, 2004 6:27 PM
1.3. John Kaster's Diamondback talk
Joe White
Covering John Kaster's preconference tutorial on what's new in Diamondback (that which we dare not call Delphi 9).
This talk was yesterday afternoon, but there wasn't enough convergence of wall power and working wireless to post it until now. So, here goes.
Before he even started the session, I caught a glimpse of Diamondback running on his machine. The first thing I noticed was that there are three tabs at the bottom of the editor window: "Code", "Design", and "History". Very intriguing.
His handouts were hefty
最低0.47元/天 解锁文章
9496
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
