Conferences

EKON 23 Dusseldorf, Germany
CodeRage 2018 online conference
EKON 22 Dusseldorf, Germany
Barnsten Delphi Conference 2018 Netherlands
Zlot Programistow Delphi, June 19th Zergrze, Poland
CodeRage XII online conference
EKON 21 Cologne, Germany
CodeRage XI online conference
SDN Event 2016 Zeist, The Netherlands
ADUG 2015 Symposium Melbourne & Canberra, Australia
Delphi Developer Days 2014 London, UK
Be-Delphi 3.0 Edegem, Belgium
CodeRage 8 online conference
SDN Event 2012 Arnhem, The Netherlands
Be-Delphi 2012 Edegem, Belgium
CodeRage 7 online conference
Mobile East 2011 Cambridge, UK
Be-Delphi 2011 Edegem, Belgium
Software Developer Conference 2011 Zeist, The Netherlands
DSConf 2011 Las Vegas, Nevada, USA
Microsoft TechEd Europe 2006 Barcelona, Spain
Software Developer Conference 2006 Arnhem, The Netherlands
DeveloperDeveloperDeveloper 2 (DDD2) Microsoft, Reading, UK
Software Developer Conference 2005 Arnhem, The Netherlands
DeveloperDeveloperDeveloper (DDD) Microsoft, Reading, UK
The Best of Delphi (Delphi 2005) Whitehall, London, UK
European Borland Conference 2004 / Entwickler-Konferenz 8 (BorCon Europe 2004 / EKON 8) Frankfurt, Germany
Borland Conference 2004 (BorCon 2004) San José, California, USA
European Borland Conference 2003 (BorCon Europe 2003) Amsterdam, The Netherlands
Borland Conference 2003 (BorCon 2003) San José, California, USA
Delphi Developers Conference 2003 (DCon 2003), Reading, UK
European Borland Conference 2002 (BorCon UK 2002), London, UK
Conference to the Point, September 2002 (CttP, Sep '02), Ede, The Netherlands
Delphi Developers Conference 2002 (DCon 2002), Reading, UK
Borland Conference 2002 (BorCon 2002), Anaheim, California, USA
European Borland Conference 2001 (BorCon UK 2001), London, UK and Noordwijkerhout, The Netherlands
Borland Conference 2001 (BorCon 2001), Long Beach, California, USA
Delphi Developers Conference 2001 (DCon 2001), Reading, UK
European Inprise Conference 2000 (ICon UK 2000), London, UK
Inprise Conference 2000 (ICon 2000), San Diego, US
Delphi Developers Conference 2000 (DCon 2000), Reading, UK
Conference to the Point, December 1999 (CttP, Dec '99), Noordwijkerhout, The Netherlands
Delphi Developers Conference 1999 (DCon '99), London, UK
Inprise Conference 1999 (ICon '99), Philadelphia, USA
European Borland Conference, 1998 (BorCon UK '98), London, UK
European Borland Developers Conference, 1997 (BorCon UK '97), London, UK
Conference to the Max, 1997 (CttM '97), Ede/Wageningen, The Netherlands
Conference to the Point, February 1997 (CttP, Feb '97), Utrecht, The Netherlands
European Paradox Conference, 1994 (EPC '94), London, UK

Click here to see some comments by people who have attended my conference sessions.

If you find useful information in these conference papers please consider making a donation. It will be appreciated however big or small it may be and will encourage Brian to continue researching, writing and speaking about interesting topics in the future.

Entwickler-Konferenz 23 (EKON 23)

• Delphi actions – for those who don’t know
  Description
  Actions have been available since Delphi 4 way back in 1998, but many developers haven’t had the need or the opportunity to get to know what they are, what they do, or why they are great. This session looks at what actions are, how they are set up, how you use them, how they simplify certain UI setup tasks, and includes a run-through of the various pre-fabricated ones supplied in the Delphi libraries. If you’ve not taken the leap to use actions yet, now is the time for.... action!
  

• Integrating with the Android ecosystem
  Description
  This session moves on from the ‘how to use Android SDK classes in your Delphi app’ and considers how to use particular Java and Android technologies in your Delphi app. Not all can be done easily or completely, but we can usually get some good results if we have the right fundamental knowledge at our disposal. We aim to get that in place in this session, looking at .jar files, .aar files, listeners, device-resident libraries, broadcast receivers, runtime permissions, version-dependant APIs, and more if time allows.
  

CodeRage 2018

• Creative Delphi Debugging Techniques
  Description
  Debugging represents a big part of development, possibly one of the biggest for many. We all know about breakpoints, single-stepping and watches, but what else can we do to help work through bug scenarios and resolve problems, such as those that have happened at customer sites?
  This session looks at a number of techniques, tricks, and utilities to help make the chore of debugging a bit more productive.
  Warning: this session may contain the CPU window!.

  The session can be viewed here at Embarcdero Academy, where you can also find the session slides and sample files.

Entwickler-Konferenz 22 (EKON 22)

• Creative Delphi Debugging Techniques
  Description
  Debugging represents a big part of development, perhaps one of the biggest. We all know about breakpoints, single-stepping and watches, but what else can we do to help work through bug scenarios and resolve problems?
  This session looks at a number of techniques, tricks, and utilities to help make the chore of debugging a bit more productive.
  Warning: this session may contain the CPU window!
  

Barnsten Delphi Conference 2018

• Creative Delphi Debugging Techniques
  Description
  Debugging represents a big part of development, perhaps one of the biggest. We all know about breakpoints, single-stepping and watches, but what else can we do to help work through bug scenarios and resolve problems?
  This session looks at a number of techniques, tricks, and utilities to help make the chore of debugging a bit more productive.
  Warning: this session may contain the CPU window!
  

• How to Access the Android API
  Description
  The ability to build Android applications is a great aspect of recent versions of Delphi, which gets more capable and functional with every release.
  However exploring outside the “FMX envelope” is still an onerous task to all but the most propeller-headed of Delphi developers.
  We’ll look at how to pull in various “not-in-the-box” features into an Android application using the latest version of Delphi and hopefully take away the mystery associated with it.
  

Zlot Programistow Delphi (Delphi programmer's Rally) 2018

• IDE Productivity Tips
  Description
  We can all benefit from becoming more proficient and efficient with our favourite development environment.
  Brian leads you through a list of time-saving IDE shortcuts and lesser-known product features to help give your Delphi programming productivity a helpful boost.
  Everyone knows a few useful tips and techniques but the plan is for everyone to walk away knowing some new tricks.
  

• How to Access the Android API
  Description
  The ability to build Android applications is a great aspect of recent versions of Delphi, which gets more capable and functional with every release.
  However exploring outside the "FMX envelope" is still an onerous task to all but the most propeller-headed of Delphi developers.
  We’ll look at how to pull in various “not-in-the-box” features into an Android application using the latest version of Delphi and hopefully take away some of the mystery associated with it.
  

CodeRage XII

• Directly Using the Android API
  Description
  Learn how to take full advantage of the Android API from Delphi.
  
  The slides and samples for this session can be downloaded from here. The session can be viewed here at Embarcdero Academy.

Entwickler-Konferenz 21 (EKON 21)

• How to Access the Android API
  Description
  The ability to build Android applications is a great aspect of recent versions of Delphi, which gets more capable and functional with every release.
  However exploring outside the “FMX envelope” is still an onerous task to all but the most propeller-headed of Delphi developers.
  We’ll look at how to pull in various “not-in-the-box” features into an Android application using the latest version of Delphi and hopefully take away the mystery associated with it.
  The slides and samples for this session can be downloaded from here.

• IDE Productivity Tips
  Description
  Everyone can benefit from becoming more efficient when working with their favourite development tool. Brian leads you through a list of time-saving IDE shortcuts and lesser-known product features to help give your Delphi programming productivity a helpful boost.
  The slides and samples for this session can be downloaded from here.

• Creative Delphi Debugging Techniques
  Description
  Debugging represents a big part of development, perhaps one of the biggest. We all know about breakpoints, single-stepping and watches, but what else can we do to help work through bug scenarios and resolve problems?
  This session looks at a number of techniques, tricks, and utilities to help make the chore of debugging a bit more productive.
  Warning: this session may contain the CPU window!
  The slides and samples for this session can be downloaded from here.

CodeRage XI

• Debug Logging in Delphi FireMonkey Apps
  Description
  This 10 minute Lightning Talk looks at FireMonkey's support for debug logging and how you can see the logging output on the various target platforms.
  
  You can download the sample files here.
  You can see the session slides here.
  

• Debug Logging in C++ FireMonkey Apps
  Description
  This 10 minute Lightning Talk looks at FireMonkey's support for debug logging and how you can see the logging output on the various target platforms.
  
  You can download the sample files here.
  You can see the session slides here.
  

SDN Event 2016

• How to Access the Android API
  Description
  Building Android applications is a great feature of modern versions of Delphi, which gets more capable with every release.
  However exploring outside the "FMX envelope" is still an onerous task to all but the most propeller-headed of Delphi barbarians.
  We'll look at how to pull in various "not-in-the-box" features into an Android application using the latest version of Delphi and hopefully take away some of the mystery associated with it.
  Slides are available here.
  

• Creative Delphi Debugging Techniques
  Description
  Debugging represents a big part of development. We all know about breakpoints, single-stepping and watches, but what else can we do to help work through bug scenarios and resolve problems?
  This session looks at a number of techniques, tricks, and utilities to help make the chore of debugging a bit more productive.
  Warning: this session may contain the CPU window!
  Slides are available here.

ADUG Symposium 2015

• Employing and Enjoying Android OS Capabilities
  Description
  Building Android applications is a great feature of modern versions of Delphi, which gets more capable in this regard with each release. However exploring outside the FMX envelope is still quite an onerous task to all but the most propeller-headed of Delphi barbarians. We’ll look at how to pull in various “not-in-the-box” features into an Android application using the latest version of Delphi and hopefully take away some of the mystery associated with it.
  

• Creative debugging techniques
  Description
  Bugs are very familiar. Debugging is all too familiar… and often quite unproductive. This session looks at a number of techniques, tricks, and utilities to help make the chore of debugging a bit more productive.
  Warning: this session may contain usage of the CPU window!

Delphi Developer Days 2014

• Non-Obvious Debugging Techniques
  Description
  We all have to debug applications, and there are many common techniques available to help things along. This session reveals a number of techniques that can be useful to aid the debugging task, but which are not of a particularly obvious nature.

Be-Delphi 3.0

• Developing for Android with Oxygene for Java
  Description
  Oxygene is an Object-Pascal based language previously well know in its .NET incarnation as Delphi Prism. Oxygene for Java produces Android apps that run where Android does - in Android's Dalvik VM. It is for those who have a background in Delphi or a history of Pascal programming from previous times, or anyone who fancies something a bit different from Java, and who wants to use the standard Android APIs in the Android SDK to build lightweight, standard Android applications (or, for that matter, Java applets, servlets, etc.) that can run on ay Android device of your choosing.
  We'll look at Oxygene for Java's capabilities and features in the context of building and deploying an Android application using OS-native controls. We'll see how the product works, bump into some enhancements to the evolving Object Pascal language and show that Oxygene for Java is a first class citizen in the world of Android development.

CodeRage 8

• Accessing the iOS API
  Description
  FireMonkey as a platform covers much of what you need to build a data-driven mobile application that can run on iOS and Android. However, sometimes Delphi iOS apps still need additional assistance from the iOS CocoaTouch frameworks. This session looks at how you can access the iOS Objective-C classes via the Objective-C bridge, looking at classes that have Delphi representations and, perhaps more importantly, those which do not, as well as demonstrating how Objective-C classes can be extended in Delphi.
  
  
  The slides and samples for this session can be downloaded from here.

• Accessing the Android API
  Description
  FireMonkey as a platform covers much of what you need to build a data-driven mobile application that can run on iOS and Android. However, sometimes Delphi native Android apps still need additional assistance from the Android SDK. This session looks at how you can access the Android Java classes via the Java bridge, looking at classes that have Delphi representations and, perhaps more importantly, those which do not.
  
  
  The slides and samples for this session can be downloaded from here.

SDN+ Event 2012

• IDE Productivity Tips
  Description
  Everyone can benefit from becoming more efficient when working with their favourite development tool. Brian leads you through a list of time-saving Delphi IDE shortcuts and lesser-known product features to help give your programming productivity a boost.
  

• Project 'Nougat'
  Description
  This session introduces RemObjects' Project 'Nougat', a Delphi-like language (Oxygene, the compiler that powers Embarcadero Prism) that builds native iOS and OS X executables talking directly to the real APIs on the target system, using real controls and producing real, native executables.

Be-Delphi 2012

• Project 'Nougat': native iOS & OS X development for Delphi programmers
  Description
  Brian introduces RemObjects' Project 'Nougat', a Delphi-like language (Oxygene, the compiler that powers Embarcadero Prism) that builds native iOS and OS X executables talking directly to the real APIs on the target system, using real controls and producing real, native iOS & OS X executables.

CodeRage 7

• IDE Productivity Tips & Techniques
  Description
  Everyone can benefit from efficiency boosts from time to time. Brian takes you on a journey through a whole list of time-saving Delphi & C++Builder IDE shortcuts and lesser known product features to help give your programming productivity a hike. The lion's share of this session is a reflection on personal experience on trying to be more efficient in the IDE.

Mobile East 2011

• Developing for Android with Oxygene for Java
  Description
  Oxygene for Java is an Object-Pascal based tool for native Java and Android development, targeting those who have a background in Delphi or a history of Pascal programming from previous times, or anyone who fancies something a bit different from Java.
  Oxygene is the next evolution of Object-Pascal, with advanced features typically only found in specialised niche languages. Such features include Duck Typing, Class Contracts, Generics, Language-integrated Parallelism, Conditional Statement Expressions and Nullable Types. The language is familiar for Delphi or Pascal developers, but powerful enough to be a true alternative to C# or Java.
  We'll look at Oxygene for Java's capabilities and features in the context of building and deploying an Android application. We'll see how the product works, bump into some enhancements to the Object Pascal language and show that Oxygene for Java is a first class citizen in the world of Android development.

Be-Delphi 2011

• Product Launch: Introducing Project "Cooper" - The Oxygene Language for Java and Android
  Description
  Come and witness the launch of RemObject's latest developer tool: Oxygene for Java (aka Project "Cooper"). Oxygene for Java is an Object-Pascal based tool for native Java and Android development. It does for the Java and Android platforms what Embarcadero's Delphi Prism (aka Oxygene for .NET) has done for the .NET and Mono platforms over the last 7 years - bringing native development for the entire target platform to the hands of Delphi developers.
  Oxygene is the next evolution of Object-Pascal, with advanced features typically only found in specialised niche languages. Such features include Duck Typing, Class Contracts, Generics, Language-integrated Parallelism, Conditional Statement Expressions and Nullable Types. The language is familiar for Delphi developers, but powerful enough to be a true alternative to C# or Java.
  We'll look at Oxygene for Java's capabilities and features. We'll walk through building an application that runs on the Java platform in some of its various guises, the implications therein and look at some enhancements to this Delphi-like Pascal-based language. We'll finish by showing how Oxygene for Java can be used to develop for Android devices by targeting Android's Dalvik Virtual Machine.

Software Developer Conference 2011

SDN
October 3-4, 2011
Zeist, NL

• Product Launch: Introducing Project "Cooper" - The Oxygene Language for Java and Android
  Description
  Come and witness the launch of RemObject's latest developer tool: Oxygene for Java (aka Project "Cooper"). Oxygene for Java is an Object-Pascal based tool for native Java and Android development. It does for the Java and Android platforms what Embarcadero's Delphi Prism (aka Oxygene for .NET) has done for the .NET and Mono platforms over the last 7 years - bringing native development for the entire target platform to the hands of Delphi developers.
  Oxygene is the next evolution of Object-Pascal, with advanced features typically only found in specialised niche languages. Such features include Duck Typing, Class Contracts, Generics, Language-integrated Parallelism, Conditional Statement Expressions and Nullable Types. The language is familiar for Delphi developers, but powerful enough to be a true alternative to C# or Java.
  

• Introductory: Getting to grips with Oxygene for Java (aka Project "Cooper")
  Description
  This session introduces Oxygene for Java, looking at its capabilities and its language features. We'll walk through building applications that run on the Java platform in some of its various guises, the implications therein and explore the various enhancements to this Delphi-like Pascal-based language. We'll finish by looking at how Oxygene for Java can be used to develop for Android devices by targeting Android's Dalvik Virtual Machine.
  

• Advanced: Oxygene for Java (aka Project "Cooper") In Use
  Description
  This session looks in detail at using Oxygene for Java in one of its more commonly envisioned usage scenarios: targeting Android devices. We'll look at various aspects involved in Android programming and how these surface when using Oxygene for Java, including an overview of Android application architecture, layout and operation, as well as building, deploying, debugging, redeploying and so on. We'll look at how resources are set up, how Android UIs are handled, support for multiple languages and device formats and how to approach various UI programming aspects. After attending this session you will be armed with an understanding of how Oxygene for Java can be successfully used to develop your Android application.

Developer Solutions Conference 2011

• Android Development with MonoDroid Brian Long & Jim McKeeth
  Description
  This session looks at the processes and techniques involved in building Android applications using Mono, MonoDroid and Delphi Prism. Going from the basics and running through the principles in Android applications, we advance to applications incorporating RemObjects DataAbstract.

Microsoft TechEd Europe 2006

• DEVWD03 - Alternative .NET Debugging Facilities
  Description
  Debugging is a necessity. Sometimes an IDE-resident debugger doesn't have what it takes to track a problem down. There are a variety of other debugging tools available from Microsoft that can come to the rescue in these and other circumstances and in this session we take a look at what's available and how you can use these tools to improve your debugging prowess. This Whiteboard discussion will sidestep Visual Studio's debugger, and maybe brush over DbgCLR and MDbg, and will focus squarely on WinDbg with Son of Strike and various supporting tools and will look at application introspection, memory consumption and miscellaneous lower level trickery.

Software Developer Conference 2006

• The .NET Profiling API
  Description
  Commercial profiling tools are all well and good but don’t always give you what you need. The .NET Profiling API provides developers comprehensive hooks into all parts of .NET and provides a rich variety of information. It facilitates building your own custom profiler to provide the information you need.
  This session looks at what the Profiling API in .NET 2.0 offers, how it operates, and how you can build some simple, but powerful profiling tools without too much effort in Delphi for Win32. Samples examined include a method call trace log (to help trace execution flow), an exception analysis tool and a general logging profiler that lists out more information than you could possibly need.

• .NET Debugging Facilities
  Description
  Debugging is a necessity. Sometimes an IDE-resident debugger doesn’t have what it takes to track a problem down. There are a variety of other debugging tools available from Microsoft that can come to the rescue in these and other circumstances and in this session we take a look at what’s available and how you can use these tools to improve your debugging prowess. Coverage will include Visual Studio.NET’s debugger as well as DbgCLR, MDbg, WinDbg with Son of Strike and various supporting tools and will look at Heisenbugs, memory tracking, ASP.NET specific issues and miscellaneous lower level trickery.

• .NET Interoperability 101 (C#)
  Description
  Developers don’t always get the luxury of rewriting an application on a new platform from scratch and so .NET offers a variety of interoperability mechanisms to move systems across piece by piece. In this session we look at the options for building .NET applications that make use of Win32 code and also Win32 applications that make use of .NET code, covering the processes involved in each case. For those considering moving an existing system to the .NET platform, interoperability can make the process workable in a stepwise manner, helping prove individual sections work correctly as they are moved across

• .NET Interoperability 101 (Delphi)
  Description
  Developers don’t always get the luxury of rewriting an application on a new platform from scratch and so .NET offers a variety of interoperability mechanisms to move systems across piece by piece. In this session we look at the options for building .NET applications that make use of Win32 code and also Win32 applications that make use of .NET code, covering the processes involved in each case. For those considering moving an existing system to the .NET platform, interoperability can make the process workable in a stepwise manner, helping prove individual sections work correctly as they are moved across.

DeveloperDeveloperDeveloper 2

• 
  Reverse Engineering To Know .NET Better
  Description
  Learning a programming platform is always an uphill struggle. With .NET there is no lack of help, information and support and around and so this in itself makes the job easier. But there are some who say that the better you know how something works on the inside, the better you can make it work from the outside (the reverse of the implementation hiding principle). This session looks at various tools and resources to find how we can learn more about how .NET works on the inside to try and provide a better understanding of what you work with.

Software Developer Conference 2005

• DN.13 - The .NET Profiling API
  Description
  Commercial profiling tools are all well and good but don’t always give you what you need. The .NET Profiling API provides developers comprehensive hooks into all parts of .NET and provides a rich variety of information. It facilitates building your own custom profiler to provide the information you need.
  This session looks at what the Profiling API offers, how it operates, what’s new in the Whidbey version and how you can build some simple, but powerful profiling tools without too much effort in Delphi for Win32. Samples examined include a method call trace log (to help trace execution flow), an exception analysis tool and a general logging profiler that lists out more information than you could possibly need.

• DN.14 - .NET Debugging Facilities
  Description
  Debugging is a necessity. Sometimes an IDE-resident debugger doesn't have what it takes to track a problem down in a .NET system. There are a variety of other .NET debugging tools available from Microsoft that can come to the rescue in these circumstances and in this session we take a look at what?s available and how you can use these tools to improve your debugging prowess in both WinForms and ASP.NET scenarios. Coverage will include the Borland Developer Studio debugger as well as CorDbg, DbgCLR, MDbg, but focus mostly on WinDbg with Son of Strike.

• DN.15 - .NET Interoperability 101
  Description
  Developers don’t always get the luxury of rewriting an application on a new platform from scratch and so .NET offers a variety of interoperability mechanisms to move systems across piece by piece. In this session we look at the options for building .NET applications that make use of Win32 code and also Win32 applications that make use of .NET code, covering the processes involved in each case. For those considering moving an existing system to the .NET platform, interoperability can make the process workable in a stepwise manner, helping prove individual sections work correctly as they are moved across.

DeveloperDeveloperDeveloper

• .NET Debugging Facilities
  Description
  

  Debugging is a necessity. Sometimes an IDE-resident debugger doesn't have what it takes to track a problem down.

  There are a variety of other debugging tools available from Microsoft that can come to the rescue in these circumstances and in this session we take a look at what’s available and how you can use these tools to improve your debugging prowess.

  Coverage will include Visual Studio’s debugger as well as CorDbg, DbgCLR, MDbg, but focus mostly on WinDbg with Son of Strike, and will look at Heisenbugs, memory tracking, and lower level trickery.

The Best of Delphi (Delphi 2005)

• IDE/Debugger/Compiler/Language Enhancements
  Description
  Delphi 8 and Delphi 2005 both add a number of features to the Delphi language and compiler. They also add a host of new features to the IDE. Delphi 2005 is brimming with features, including lots of welcome additions to the debugging support. During the session (which will be conducted at break neck speed, the only speed possible to give a fair run through what's on offer in the most recent Delphi releases) we will look at what has been changed, improved and added. The general press makes strong references to some of the major features such as source code refactorings (such as rename across multiple source files and extract method) and unit testing, and these are looked at in separate sessions. But many of the other productivity features (such as Sync Edit, Help Insight, Error Insight, comment toggle, source history and difference reporting, multiple debuggee support) and other enhancements (such as the Delphi for .NET enhancements being migrated to the Win32 compiler, ability to view local variable values up the call stack, function inlining, better Web app debugging, project manager file system support) get less coverage. In the short amount of time available, I will try to do the impossible and run through all these features, in fact as many features as possible to show the power available in Delphi.

• Migration to .NET
  Description
  Moving existing Win32 code across to .NET can be trivial in places. However real applications throw up problem areas where some knowledge is required to help transform code that just won't work in .NET into code that works just fine. The issues you might bump into are wide-ranging, but given the right approach a solution should be available. Various techniques supported in Win32 and a number of language and RTL features are no longer at your disposal - how do you replace them? Using utility DLLs or complex Win32 APIs often requires pointers at some level, which are not the done thing in .NET - how do you reconcile these conflicting requirements? What fundamental Delphi building blocks will simply not move and need to be rewritten from the ground up? All these questions and more should be answered by the end of this session that looks at the most common and the most painful issues to crop up in code migration. One day you will be coding for .NET - it's inevitable. If you want to take your Win32 code with you then you need to attend this session

European Borland Conference 2004 / Entwickler-Konferenz 8 (BorCon Europe 2004 / EKON 8)

• DL15 - .NET Internals: Profiling .NET Applications
  Description
  In this session we look inside .NET applications using the Profiling API to see the rich volume of information made available, which allows you to build flowtrace analysers, hotspot identifiers, exception recorders, coverage analysis tools and so on.

• DL15 - Interoperability Between .NET and COM with Delphi "Diamondback"
  Incorporated with the session below.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET provides the ability for COM and .NET components to communicate almost transparently allowing applications to be developed and extended with COM or .NET. This session shows how .NET managed code can interoperate with unmanaged COM clients and servers using the COM Interop mechanism. Its intention is to address these two interoperability options:

  • .NET client applications using COM objects (RCW)
  • COM client applications using .NET managed objects (CCW)

• DL15 - Interoperability Between .NET and Win32 with Delphi "Diamondback"
  Incorporated with the session above.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET has various ways of interoperating with Win32 code. .NET apps can use routines exposed from DLLs and also any Win32 API. Additionally, existing Win32 apps can use routines exposed from .NET assemblies. using these facilities you can start building applications that bridge both worlds, taking advantage of your existing Win32 knowledge whilst learning the .NET platform.
  This session shows how .NET managed code can interoperate with unmanaged Win32 code using the PInvoke and Inverse PInvoke mechanisms. Its intention is to address these two interoperability options:

  • .NET applications using unmanaged Win32 APIs and entry points exported from your own DLLs (PInvoke)
  • Win32 applications using managed methods exposed from managed .NET assemblies (Inverse PInvoke)
  
  Note that this session includes coverage of some new features in Delphi "Diamondback"

Borland Conference 2004 (BorCon 2004)

• Delphi Tips and Techniques
  1002. Preconference tutorial.
  Description
  This session is the culmination of 9 years of using, troubleshooting and problem-solving with Delphi. You can think of this session as a brain dump of many, many tips, tricks and techniques in various areas of Delphi that many developers are unaware of.
  Areas covered will include the IDE, the RTL, the VCL, debugging, including information about the upcoming Delphi "Diamondback". Within each area we will look at non-obvious aspects that are often overlooked, sometimes by a lack of documentation, sometimes by a lack of experience, sometimes by a lack of familiarity.
  Bring plenty of note paper as we will be covering a lot of ground in this tutorial.
  
  

• Interoperability Between .NET and COM with Delphi "Diamondback"
  3222. Incorporated with the session below.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET provides the ability for COM and .NET components to communicate almost transparently allowing applications to be developed and extended with COM or .NET. This session shows how .NET managed code can interoperate with unmanaged COM clients and servers using the COM Interop mechanism. Its intention is to address these two interoperability options:
  • .NET client applications using COM objects (RCW)
  • COM client applications using .NET managed objects (CCW)

• Interoperability Between .NET and Win32 with Delphi "Diamondback"
  3222. Incorporated with the session above.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET has various ways of interoperating with Win32 code. .NET apps can use routines exposed from DLLs and also any Win32 API. Additionally, existing Win32 apps can use routines exposed from .NET assemblies. using these facilities you can start building applications that bridge both worlds, taking advantage of your existing Win32 knowledge whilst learning the .NET platform.
  This session shows how .NET managed code can interoperate with unmanaged Win32 code using the PInvoke and Inverse PInvoke mechanisms. Its intention is to address these two interoperability options:

  • .NET applications using unmanaged Win32 APIs and entry points exported from your own DLLs (PInvoke)
  • Win32 applications using managed methods exposed from managed .NET assemblies (Inverse PInvoke)
  Note that this session includes coverage of some new features in Delphi "Diamondback"
  
  

European Borland Conference 2003 (BorCon Europe 2003)

• .NET Internals: Profiling .NET Applications
  DL15.
  Description
  In this session we look inside .NET applications using the Profiling API to see the rich volume of information made available, which allows you to build flowtrace analysers, hotspot identifiers, exception recorders, coverage analysis tools and so on.

• .NET Interoperability With Win32
  DL16.
  Description
  This session shows how .NET managed code can interoperate with unmanaged Win32 code using the PInvoke and Inverse PInvoke mechanisms. Its intention is to address two interoperability options:

  • .NET applications using unmanaged Win32 APIs and entry points exported from your own DLLs (PInvoke)
  • Win32 applications using managed methods exposed from managed .NET assemblies (Inverse PInvoke)

Borland Conference 2003 (BorCon 2003)

• Delphi Tips and Techniques
  3010. Preconference tutorial.
  Description
  This session is the culmination of 8 years of using, troubleshooting and problem-solving with Delphi. You can think of this session as a brain dump of many, many tips, tricks and techniques in various areas of Delphi that many developers are unaware of.
  Areas covered will include the IDE, the RTL, the VCL, debugging. Within each area we will look at non-obvious aspects that are often overlooked, sometimes by a lack of documentation, sometimes by a lack of experience, sometimes by a lack of familiarity.
  Bring plenty of note paper as we will be covering a lot of ground in this tutorial.

• Interoperability Between .NET and COM
  3198.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET provides the ability for COM and .NET components to communicate almost transparently allowing applications to be developed and extended with COM or .NET. This session shows how .NET managed code can interoperate with unmanaged COM clients and servers using the COM Interop mechanism. Its intention is to address these two interoperability options:

  • .NET client applications using COM objects (RCW)
  • COM client applications using .NET managed objects (CCW)

• Interoperability Between .NET and Win32
  3100.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET has various ways of interoperating with Win32 code. .NET apps can use routines exposed from DLLs and also any Win32 API. Additionally, existing Win32 apps can use routines exposed from .NET assemblies. using these facilities you can start building applications that bridge both worlds, taking advantage of your existing Win32 knowledge whilst learning the .NET platform.

  This session shows how .NET managed code can interoperate with unmanaged Win32 code using the PInvoke and Inverse PInvoke mechanisms. Its intention is to address these two interoperability options:

  • .NET applications using unmanaged Win32 APIs and entry points exported from your own DLLs (PInvoke)
  • Win32 applications using managed methods exposed from managed .NET assemblies (Inverse PInvoke)

• Actions, Action Lists, and Action Managers
  6102 . CD-only paper.
  Description
  How to use actions, action lists and action managers to simplify UI management in VCL applications. Covers custom actions, standard actions and ActionBands including changes made in Delphi 7.

Delphi Developers Conference 2003 (DCon 2003)

• Reverse Engineering To Learn .NET Better
  Advanced.
  Description
  Learning a new programming platform is always an uphill struggle. With .NET there is no lack of help, information and support around and so this in itself makes the job easier. But there are some who say that the better you know how something works on the inside, the better you can make it work from the outside (the reverse of the implementation hiding principle). This session looks at various tools and resources to find how we can learn more about how .NET works on the inside to try and provide a better understanding of what you work with.

• .NET Interoperability With Win32
  Advanced.
  Description
  When starting to build new systems that work in the new .NET environment you will not be wanting to throw away all your previous code, so .NET has various ways of interoperating with Win32 code. .NET apps can use routines exposed from DLLs and also any Win32 API. Additionally, existing Win32 apps can use routines exposed from .NET assemblies. using these facilities you can start building applications that bridge both worlds, taking advantage of your existing Win32 knowledge whilst learning the .NET platform.
  This session shows how .NET managed code can interoperate with unmanaged Win32 code using the PInvoke and Inverse PInvoke mechanisms. Its intention is to address these two interoperability options:
  • .NET applications using unmanaged Win32 APIs and entry points exported from your own DLLs (PInvoke)
  • Win32 applications using managed methods exposed from managed .NET assemblies (Inverse PInvoke)

• .NET Internals: Profiling .NET Applications
  Advanced.
  Description
  So you've read the high level .NET information available on the Web, but it doesn't give you what you feel you need. You need a geek's tour of .NET under the hood and this type of information is quite hard to locate. You need to come to this session, targeted at the technically minded. In this session we look inside .NET applications using the Profiling API to see the rich volume of information made available, allowing you to build flowtrace analysers, hotspot identifiers, exception recorders coverage analysis tools and so on.

European Borland Conference 2002 (BorCon UK 2002)

• .NET Interoperability: .NET <-> Win32
  Description
  Whilst .NET may be the upcoming Windows programming platform of the future, right now there is still a lot of plain, unmanaged Win32 code around. This session looks at how .NET managed code can interoperate with unmanaged Win32 code using the PInvoke and Inverse PInvoke mechanisms. In particular we look at:
  
  • .NET applications using non-managed Win32 APIs and entry points in your own DLLs
  • Win32 applications using methods in managed .NET assemblies

• .NET Interoperability: COM Interop
  Description
  Whilst .NET may be the Windows platform of the future, right now there is still a lot of COM code around. This session looks at how .NET managed code can interoperate with Win32 COM clients and servers using the COM Interop mechanism. In particular we look at:
  
  • .NET client applications using COM objects
  • COM client applications using .NET managed objects
  
  
• Using Speech in Delphi Applications
  Description
  This talk demonstrates how to add speech synthesis and speech recognition capabilities to Delphi applications using the Microsoft Speech API.

Conference to the Point, September 2002 (CttP, Sep '02)

• Things They Don't Tell You On A Delphi Training Course
  This talk looks at as many tips and tricks for productive use of the IDE as can fit into the available time.

• Speech Synthesis And Speech Recognition
  This talk looks at how to add speech synthesis and speech recognition capabilities to Delphi applications using the Microsoft Speech API.

Delphi Developers Conference 2002 (DCon 2002)

• Things They Don't Tell You On A Delphi Training Course
  Delphi and Kylix tracks.
  Intermediate.
  Description
  A fast-paced array of IDE tips & tricks as used by experts. These are the things that are hard to find in manuals, and often omitted from training courses, typically learned from hard earned experience.

• Demystifying Interfaces
  Delphi and Kylix tracks.
  Beginner.
  Description
  This session looks at what interfaces are and what benefits they give to Delphi developers in applications that do not use COM or CORBA.

• Speech Recognition And Speech Synthesis
  Delphi track.
  Intermediate.
  Description
  This talk demonstrates how to add speech synthesis and speech recognition capabilities to Delphi applications.

Borland Conference 2002 (BorCon 2002)

At BorCon 2002 I was pleases to be voted as the Best Speaker of the conference through the attendee session evaluation forms.

• Actions, Action Lists, and Action Managers
  2110. Delphi, C++Builder, Linux and Windows Tracks.
  Description
  How to use actions, action lists and action managers to simplify UI management in VCL applications. Covers both custom actions and standard actions.

• Delphi and C++Builder Tips and Techniques
  3134. Delphi, C++Builder, Linux and Windows Tracks.
  Description
  A fast-paced array of IDE tips & tricks as used by experts. These are the things that are hard to find in manuals, and often omitted from training courses, typically learned from hard earned experience.

• Non obvious Debugging Techniques
  3188. Delphi, C++Builder and Windows Tracks.
  Description
  We all have to debug applications, and there are many common techniques available to help things along. This session reveals a number of techniques that can be useful to aid the debugging task, but which are not of a particularly obvious nature.

European Borland Conference 2001 (BorCon 2001)

• Implementing Professional Drag & Drop In VCL/CLX Applications
  3104. Delphi, RAD & Kylix Tracks.
  Description
  Simple intra-application drag and drop support is easy to add to a VCL/CLX application. However, customising the operation, for example the mouse sensitivity, the information sent along with the operation, the mouse cursor, the associated drag image, and so on... All these things take more work.
  This session looks at all the VCL/CLX underpinnings necessary to get professional looking drag and drop support in your own applications and components, and discusses the pitfalls that will trip up the unwary.

• VCL Sourcery
  4100. Delphi, C++Builder and RAD Tracks.
  Description
  Some, but very few, Delphi Developers know the Visual Component Library source code like the back of their hand. Most Delphi Developers have taken a sneak peek inside the odd VCL source file to see what's around and run away shaking and grinding their teeth. If you want to be led by the hand and taken for a viewing of the VCL from the comfort of a chair in a darkened room, come to this session. We take a leisurely stroll through the VCL source code, removing its mystique and seeing what insights we can gain.

• Debugging With More Than Watches And Breakpoints
  4104. Delphi, C++Builder and RAD Tracks.
  Description
  Delphi has always had a rich variety of debugging facilities, including the infamous CPU window. Despite being fully available in Delphi 4 and 5 (as well as in the historically popular standalone Turbo Debugger), this tool is not very well understood and developers often shy away from it. This is unfortunate, because when used well, it proves to be one of the most direct and powerful debugging aids to the developer.
  Unfortunate but understandable, as the first thing you see when opening the window is a lot of assembler instructions. In order to help make the window more approachable, we will briefly look at a few of the more common assembler commands, and use this information to see how we can track down those pesky memory problems.
  This talk will open up the CPU window to the meekest of Delphi users and show how numerous logic problems can be identified using it.
  Knowledge of the contents of the System unit will be employed to show how we can traverse the internals of objects and variants to verify their condition.
  Additionally, the event log window (amongst other IDE tools) will be used as a stage to show techniques that can be used to help narrow down hard-to-track bugs in your programs.

Borland Conference 2001 (BorCon 2001)

• Delphi and C++Builder Tips and Techniques (or, Things They Don't Tell You On A Training Course)
  2106. Delphi, C++Builder and Windows Tracks.
  Description
  A fast-paced array of tips & tricks as used by experts. These are the things that are hard to find in manuals, and often omitted from training courses, typically learned from hard-earned experience.

  Abstract
  Have you ever watched a seasoned Delphi or C++Builder developer strut his/her stuff in the IDE?
  Have you sat and watched, wondering how they marked that strangely shaped block of text?
  Have you ever wondered how they fixed that problem of CAPS LOCK being on by inverting the case of several lines of source code?
  Have you ever wondered what you are missing in the code editor?
  Have you ever wondered about how to do more with the IDE than is described in the manual?
  Have you ever wondered how to have a closer relationship between yourself and the clipboard when coding?
  Have you ever wondered what to do with some of those strange tools that come with Delphi and C++Builder?
  Have you ever wondered how to accommodate version dependent code in your Delphi or C++Builder project?
  Have you wondered many of these things, or other things besides? Then come to this session where all the tips and tricks that can be squeezed into one talk will be covered.

• How to do COM in C++Builder
  3190. C++Builder and Windows Tracks.
  Description
  COM is a fashionable buzzword these days. This talk leads the newcomer to the subject through the concepts and terms, allowing them to understand the facts of the subject.

  Abstract
  This session looks at the subject of COM (and COM+) and explores how applications are written to take advantage of this technology using C++Builder. This requires us to get an understanding of an interface, which is the bread and butter of a COM application.
  As COM servers and clients are written, a lot of terminology gets thrown around, so we will ensure that all key terms are fully explained.
  Issue such as registration, marshaling, custom data formats and instancing will be explored during the talk.

• Run Time Type Information in C++Builder 5 - What Can It Do For You?
  3254. C++Builder and Windows Tracks.
  Description
  This session introduces Runtime Type Information (RTTI) structures and routines to simplify many programming tasks.

  Abstract
  RTTI exists in all C++Builder VCL applications, primarily to allow the application to function at all. It is used to load form files and create the initial representation of each form, as set at design-time. It is also used extensively by the design time environment to allow the Object Inspector to operate.
  This session looks at what information is stored in RTTI, how we access it and why we might want to do so. We will find that RTTI can be applied to a number of situations to simplify a variety of programming tasks.

• Implementing Professional Drag & Drop In VCL/CLX Applications
  4114. Delphi, C++Builder, Kylix, Windows and Linux Tracks.
  Description
  This session illustrates how to implement simple drag and drop both within an application and to enhance it to a professional level.

  Abstract
  Simple intra-application drag and drop support is easy to add to a VCL/CLX application. However, customising the operation, for example the mouse sensitivity, the information sent along with the operation, the mouse cursor, the associated drag image, and so on... All these things take more work.
  This session looks at all the VCL/CLX underpinnings necessary to get professional looking drag and drop support in your own applications and components, and discusses the pitfalls that will trip up the unwary.

Delphi Developers Conference 2001 (DCon 2001)

• Linux Basics for Kylix Developers
  Pre-conference training session
  Description
  This tutorial session, will cover all the basics that a developer needs to know about Linux to enable them to develop systems using Kylix and will cover the following topics:
  • What is Linux?
    • Where Linux came from
    • Linux philosophies (GNU, GPL, Open Source)
    • The shell
    • Distributions
  • Basic Linux commands
  • The Linux file system
  • Linux users
  • User accounts
  • Group accounts
  • File permissions
    • Symbolic mode
    • Absolute mode
    • umask and default file permissions
    • suid, sgid and sticky bits
  • The Bash shell
    • Bash and other shells
    • Customising the login process
    • Customising your command prompt
    • Executing commands
    • Command history
    • Filename completion
    • Keyboard shortcuts
    • Shell scripts
  • The X Window system
    • Window managers
    • Widget libraries (GTK/GTK+, QT)
    • Desktop environments (GNOME, KDE)
  • Installing software on Linux
    • Tar balls
    • RPMs
  • More Linux commands
  • The Linux boot process
    • init
    • Runlevels
  • Connecting to Windows drives with Samba
  • Apache Web server
  • Kylix Installation

• VCL vs. CLX - A Comparison
  Delphi and Kylix tracks.
  Intermediate.
  Description
  Borland have touted the CLX as being as similar as possible to the VCL, causing as few source change requirements as they could. At the surface, the two libraries are very similar, but there are differences to be seen. More interesting, though, is what goes on inside the libraries.
  How do their designs and implementations differ?
  What must an experienced VCL user know to successfully build CLX applications?
  This session embarks on an investigation below the surface of the CLX to answer these questions and more.
  Prerequisite: None

• How to Use Actions, Action Lists and Action Managers
  Delphi track.
  Beginner.
  Description
  Actions, introduced in Delphi 4, allow you to centralise functionality that may be invoked by the user in many ways. They also allow you to easily split the "doing" part of the action, from the "validating" part.
  This talk is split into two parts. The first section looks at how actions can be used in applications to help simplify the process of non-trivial UI development. The second part looks at the new action managers to see how they can enhance the UI further and allows easy customisation by the user.
  Prerequisite: None

• Debugging With More Than Watches And Breakpoints
  Delphi and Kylix tracks.
  Intermediate.
  Description
  Delphi has always had a rich variety of debugging facilities, including the infamous CPU window. Despite being fully available in Delphi 4 and 5 (as well as in the historically popular standalone Turbo Debugger), this tool is not very well understood and developers often shy away from it. This is unfortunate, because when used well, it proves to be one of the most direct and powerful debugging aids to the developer.
  Unfortunate but understandable, as the first thing you see when opening the window is a lot of assembler instructions. In order to help make the window more approachable, we will briefly look at a few of the more common assembler commands, and use this information to see how we can track down those pesky memory problems.
  This talk will open up the CPU window to the meekest of Delphi users and show how numerous logic problems can be identified using it.
  Knowledge of the contents of the System unit will be employed to show how we can traverse the internals of objects and variants to verify their condition.
  Additionally, the event log window (amongst other IDE tools) will be used as a stage to show techniques that can be used to help narrow down hard-to-track bugs in your programs.
  (Although this session was presented at last years DCON the selection committee felt it important to show the debugging facilities in Kylix and the latest version of Delphi)
  Prerequisite: Basic knowledge of Delphi’s debugging features.

European Inprise Conference 2000 (ICon UK 2000)

• More Automation in Delphi
  Delphi Track.
  Description
  Advanced Automation servers have features that are desirable in some of our own Automation applications. We look at how to emulate them in this session.

  Abstract
  This session looks at Automation events - a way for an Automation server to trigger code in a given client application (or applications).
  We also look at the issue of instancing, particularly focusing on how to get all client applications to connect to a single Automation object in one executable.
  The traditional academic Automation application has one object defined. We will investigate how to deal with more than one object, looking to Microsoft Office applications for guidance.
  Finally, we will look at implementing Automation collections, again something common in Microsoft Office. Care must be taken to cater for VB's in-built knowledge of these structures.

• How to do COM in C++Builder
  Enterprise & Technology Track.
  Description
  COM is a fashionable buzzword these days. This talk leads the newcomer to the subject through the concepts and terms, allowing them to understand the facts of the subject.

  Abstract
  This session looks at the subject of COM (and COM+) and explores how applications are written to take advantage of this technology using C++Builder. This requires us to get an understanding of an interface, which is the bread and butter of a COM application.
  As COM servers and clients are written, a lot of terminology gets thrown around, so we will ensure that all key terms are fully explained.
  Issue such as registration, marshaling, custom data formats and instancing will be explored during the talk.

Inprise Conference 2000 (ICon 2000)

Brian was invited to make three talks at ICon 2000 (one of them was to be made twice). He had to politely decline the invitation however, as ICon 2000 coincided with the due date of his first child, Reuben.

• Run Time Type Information (RTTI) In C++Builder - Can It Do Anything For You?
  This talk was to look at what RTTI is in a VCL application, how it comes to be, how it is implicitly used by the IDE and by your application and also how it can be used by your own code to simplify certain programming challenges. It will contrast the VCL (or Delphi style) RTTI from normal C++ RTTI to show how different they are, and what their different uses can be.

• An Introduction To VCL Component Building in C++Builder (to be made twice)
  This was to look at how components can be written in C++Builder and be placed on the Component Palette. Clearly there are some differences between a normal C++ object and a component, and this talk would explore these. Properties and events would be explained, as would the use of special properties and methods dedicated to the component writer.

• Advanced VCL Component Building
  To make components appear professional, there are certain things that you need to take into account, and certain techniques you need to be aware of. Linked components, data-aware components, components that have a nice, helpful design-time presence, components that contain other objects... All these would be looked at in this session.

Delphi Developers Conference 2000 (DCon 2000)

• Deep sea fishing in Delphi (VCL secrets and the practical use of the Win32 API)
  Pre-conference training session
  Abstract
  This training session dives below the relatively calm surface of the VCL and searches for buried treasures in the source code that escape the eye of most developers. It also tempts the turbulent waters of the Win32 API, looking at how Delphi programmers can talk to these many routines and what magic can be done with them.

  Bring your water wings.

  Description
  Delphi provides a happy home for many developers. Using the components on the component palette, along with a useful set of routines, people get by quite happily with the product. Home sweet home.

  But do you just want to get by? Or do you want to stride forward, using Delphi as a weapon to battle against a variety of programming problems?
  

  If you are of the mindset to say yes to this question, then this training session is for you.
  

  Here we will look beyond the well known components and objects in the Visual Component Library (VCL), looking into the depths of the Run-Time Library (RTL). There we will find unseen treasures, a huge amount of functionality going to waste. Without resorting to a heap of third-party add-ons you can attack a horde of programming problems with a full armoury.
  

  Variables, routines, hooks, pointers, types, constants, techniques and more will be explored.
  

  As well as looking at what often goes unused in Delphi, we will also turn our attention to the Windows API. Many a task can be accomplished using appropriate APIs (in fact Windows applications only function because they are calling many Windows APIs already).
  

  We will consider a number of common and not so common problems that can be solved by prudent API programming. Some of the common problems include launching applications, allowing the user to choose a folder and finding the user name of the logged in user. The less common problems will include locating an arbitrary window in the Windows system, by iterating across every window that exists.
  

  There are a number of guidelines which need to be followed when trying to tackle the Windows API, which we will identify and follow in order to solve the problems.

• Debugging With More Than Watches And Breakpoints
  Intermediate.
  Abstract
  Investigating the more advanced debugging tools available in Delphi that can be used for effective, targeted debugging. Focuses on the CPU window and event log.

  Description
  Delphi has always had a rich variety of debugging facilities. Delphi 1 had the traditional 3GL offerings, including single-stepping (stepping into and over subroutines) as well as breakpoints (which can have an associated condition or pass count). Some viewing windows (for watches, breakpoint properties and a function call stack) and an evaluate and modify area completed the set.

  Things didn't really change much when Delphi went 32-bit with version 2, apart from the ability to view additional execution threads in your process.

  Version 3 added (well, almost added) the CPU window to the set (as well as the modules window), but as it was not quite finished it has to be enabled with an undocumented option.

  Despite being fully available in Delphi 4 and 5 (as well as in the historically popular standalone Turbo Debugger), the CPU window is not very well understood and developers often shy away from it. This is unfortunate, because when used well, it proves to be one of the most direct and powerful debugging aids to the developer.

  Unfortunate but understandable, as the first thing you see when opening the window is a lot of assembler instructions. In order to help make the window more approachable, we will briefly look at a few of the more common assembler commands, and use this information to see how we can track down those pesky memory problems.

  This talk will open up the CPU window to the meekest of Delphi users and show how numerous logic problems can be identified using it.

  Knowledge of the contents of the System unit will be employed to show how we can traverse the internals of objects and variants to verify their condition.

  Additionally, the event log window (amongst other IDE tools) will be used as a stage to show techniques that can be used to help narrow down hard-to-track bugs in your programs.

• IDE/RTL/VCL/ObjectPascal Tips
  Beginner.
  Abstract
  A fast-paced array of tips & tricks as used by experts. These are the things that are hard to find in manuals, and often omitted from training courses, typically learned from hard-earned experience (and researching problems and articles for The Delphi Mag).

  Description
  Have you ever watched a seasoned Delphi developer strut his/her stuff in the Delphi IDE?

  Have you sat and watched, wondering how they marked that strangely shaped block of text?

  Have you ever wondered how they fixed that problem of CAPS LOCK being on by inverting the case of several lines of source code?

  Have you ever wondered how these people step over various hurdles presented by the language and accessed protected or private member fields of objects?

  Have you ever wondered what you are missing in the code editor?

  Have you ever wondered whether there were ways to simplify those cumbersome statements?

  Have you ever wondered about how to do more with the IDE than is described in the manual?

  Have you ever wondered how to have a closer relationship between yourself and the clipboard when coding?

  Have you ever wondered what to do with some of those strange tools that come with Delphi?

  Have you ever wondered how to accommodate version dependent code in your Delphi project?

  Have you wondered many of these things, or other things besides? Then come to this session where all the tips and tricks that can be squeezed into one talk will be covered.

Conference to the Point, December 1999 (CttP, Dec '99)

• Run Time Type Information (RTTI) In Delphi
  A thorough explanation of RTTI in terms of what it is, why it is here and what it is used for is followed by various examples of how you can use it for your own purposes. A number of applications are presented throughout this session.

• Delphi VCL Sourcery
  This session looks at the often overlooked VCL and RTL source code, hunting for useful tidbits to share. We will find a number of things that practically all Delphi developers are unaware of, which can be potentially useful during application development.

Delphi Developers Conference 1999 (DCon '99)

• CORBA and Delphi
  Essentials Track.
  The intent of this session is to help you appreciate CORBA and the development of CORBA applications in the Delphi environment, and also to get an understanding of many of the strange terms, phrases and acronyms used within the world of CORBA. During the session, we develop a CORBA object within a CORBA server application, and also manufacture a CORBA client application. These applications talk to each other on the same machine and also across a network link, so that you can see all the mechanisms required for the successful implementation and execution of a distributed CORBA application. Since Delphi obscures a lot of what goes on in CORBA-based applications, additional explanations focus on what happens behind the scenes and under the bonnet, so you can appreciate the level of support given by default by your development tool of choice.

• VCL Sourcery
  Essentials Track.
  Some, but very few, Delphi Developers know the Visual Component Library source code like the back of their hand. Most Delphi Developers have taken a sneak peek inside the odd VCL source file to see what's around and run away shaking and grinding their teeth. If you want to be led by the hand and taken for a viewing of the VCL from the comfort of a chair in a darkened room, come to this session. We take a leisurely stroll through the VCL source code, removing its mystique and seeing what insights we can gain.

• Frequently Asked Questions (FAQs) (with Bob Swart)
  Essentials Track.
  Bob and Brian draw on their extensive online experience to present a session on the most frequently asked questions posed by Delphi developers, and covers the pitfalls that many fall into. Delphi is indeed a Rapid Application Development tool, but this creates problems of its own. A Windows developer using Delphi has to come to grips with not one but three entirely different things: Windows programming, the Object Pascal language, and the Visual Component Library (VCL). This session presents a host of tips, tricks and answers to many of the awkward "how do you that" questions that most developers pose at one time or another.

• The Delphi Clinic (with Steve Teixeira) Essentials Track.
  This was an evening discussion group where audience members posed questions to Steve and I.

Inprise Conference 1999 (ICon '99)

• Writing And Controlling Automation Servers In C++Builder 4
  3192. C++Builder Track.
  Investigating the easy (but slow) and potentially more tricky (but more efficient) mechanisms for controlling an automation server and, indeed, writing one in C++Builder.

• Run Time Type Information (RTTI) In C++Builder 4 - Can It Do Anything For You?
  4050. C++Builder Track.
  Maybe you've heard of RTTI and maybe you haven't. This session explains its primary intended purpose, and how you can take advantage of it to simplify some common and some less common programming tasks.

European Borland Conference, 1998 (BorCon UK '98)

• Writing And Controlling Automation Servers In C++Builder 3
  CB100. C++Builder Track.
  This session will demonstrate how Automation can be easily employed to control common Windows applications such as Microsoft Word and Microsoft Excel. Different approaches of writing your own Automation Server applications will be explored to show the most efficient way of implementing this powerful technique.

• Run Time Type Information (RTTI) In C++Builder 3 - Can It Do Anything For You?
  CB140. C++Builder Track.
  A thorough explanation of RTTI in terms of what it is, why it is here and what it is used for is followed by various examples of how you can use it for your own purposes. A number of applications are presented throughout this session.

• Run Time Type Information (RTTI) In Delphi 3 – Can It Do Anything For You?
  This is a Delphi-equivalent to the above paper.

European Borland Developers Conference, 1997 (BorCon UK '97)

• Borland C++Builder For Delphi Users
  IN060. C++Builder Track.
  A look at how the language constructs differ between Delphi and C++Builder. Comparison of files in a project, basic syntax differences, more interesting syntax differences, dealing with sets and open arrays and class references etc.

• Interfacing C++Builder With The World Using OLE Automation
  IN080. C++Builder Track.
  Borland's new C++Builder tool gives developers the power of a true Rapid Application Developemnt environment with the C++ language behind it. This makes it a great complement for other tools. We'll explore using C++ Builder with Delphi, VB, PowerBuilder and other variants of C++.

• Using The Windows API In Delphi
  CD010. CD Only.
  How to interact with the Windows API, and how to calling various Windows API routines to achieve certain ends.

Conference to the Max 1997 (CttM '97)

• Run-Time Type Information (RTTI) In Delphi
  Delphi Track.
  A thorough explanation of RTTI in terms of what it is, why it is here and what it is used for is followed by various examples of how you can use it for your own purposes. A number of applications are presented throughout this session.

• Using The Windows API In Delphi
  Delphi Track.
  This session looks at how to approach the Windows API, how to find information out about it, how to read the C API syntax and how to accomplish some common requirements using Windows APIs.

Conference to the Point, February 1997 (CttP, Feb '97)

• Delphi 3.0 Has Packages Of New Features
  A run-through of all the new features available in Delphi 3, covering the IDE enhancements as well as new language features. This talk (quite briefly) covers interfaces, COM and packages.

• Automation Servers And Controllers In Delphi 2
  This session explores the subject of Automation, showing how Delphi supports controlling Automation servers through Variant variables. It then moves on to show how you can write an Automation server of your own, using the special automated section of a class, which can then be controlling by any language capable of talking to Automation servers.

European Paradox Conference, 1994 (EPC '94)

• An In-Depth Look Into ReportSmith
  Client/Server Track.
  The new Borland report writer - explaining many of ReportSmith's powerful interactive features and usage of the ReportSmith programming language (ReportBasic).