I have 3 almost identical versions with different datamodules:

• a BDE version using TQuery components and this gives good performance and can do nested SQL statements but the BDE is problematic to install in a network environment, particularly with 64bit windows becoming more common, but more importantly, the BDE truncates varchar fields to 255 characters which is very limiting unless in SQL you convert them to text in which case they become memo fields, but then you need to inform user their input will be truncated to maximum of varchar setting.
• a DBExpress version using TSQLDatasets which gives good performance but tends to have a few issues and cannot do nested SQL statements for complex reports.
• an ADO version using TADOQuery components which gives poor performance, presumably as the ADO components also cache the data as do the TClientDatasets. I no longer use this version.

The word from Embarcadero now that they have purchased the excellent 3rd party database components – AnyDAC, is that AnyDAC will be included in Delphi XE4 – presumably late 2013 – but is no longer available for purchase separately, and that the DBExpress technology is likely to be deprecated given they had troubles addressing a few of its issues.

Given this news and not wanting to wait until Delphi XE4, I decided to jump in and buy DevArt’s UniDAC components for Delphi which come highly recommended.

The process of migration and the issues it raises.

After installing the Unidac components – very painless process indeed, you will discover a new item on the Delphi IDE menu bar – UniDAC under which you will find a Migration Wizard tool.

The good news is that the Migration Wizard is very easy to use and seems to work well by converting the BDE components to UniDAC components – just tell it which folder to convert and away it goes (best to back everything up first of course, although the wizard does have an optional backup functionality).

The bad news is that although the wizard will migrate from BDE, ADO and other DevArt components such as SDAC,  there is no option to migrate from DBExpress – this seems like it would require a significant amount of search and replace work in the pas and dfm files.

Obviously some BDE features will not be supported such as aliases and if your database connection or your code relies on this then these aspects will need addressing.

You will have to set the properties on the TUniConnection component (UniDAC database driver, server, database, username, password, then look in SpecificOptions to enter ApplicationName, WorkstationID, etc), plus you will need to reconnect all your dataset.connection properties to the TUniConnection component, plus if you are like me and using TClientDatasets, then you should set all the TUniQuery.UniDirectional = true.

If any of your SQL has double quotes, these will need to be changed to single quotes – easiest way to do this is by opening the datamodule as text file (right click then select “View as text”), then do a search and replace, replacing all ” with two single quotes.

Finally, you will need to drop the UniDAC provider components onto your datamodule – eg. TSQLServerUniProvider, TASEUniProvider.

Issues thus far:

• certain TClientDatasets with Sybase “text datatype” fields crash the system when active set to true in either IDE or runtime if using the Sybase ASE connection – I am yet to work out what specifically is causing this when other similar datasets function well, and the TUniQuery opens rapidly without issue and the supplied DevArt dbMonitor suggests all is well. This is presumably an issue with the Sybase ODBC driver rather than UniDAC, and I would try changing to the DBExpress Sybase driver via UniDAC if I didn’t have to change all my datetime fields to SQLTimestamp fields.
• UniDAC TUNiQuery does not allow nested SQL statements even if these are returning a single dataset.
• Sybase ASE, Access, DB2, DBF databases are accessed via ODBC driver instead of a Direct UniDAC driver as is the case with Oracle, MS SQL Server, PostgreSQL, SQLite, and NexusDB
• I am getting key violation errors which I didn’t get with record inserts with the BDE version – this may be related to the Sybase ODBC component – will investigate

Benefits of UniDAC:

• no dll’s or BDE to install on end-user system which allows for a self-installing, self-configuring application to be easily made
• performance seems good
• ability to use multiple database engines and even write database-specific SQL with macros allowing clauses such as if Oracle then … etc. “server-independent SQL”
• built-in debug option – set debug property to true and when dataset is opened, a dialog will display the SQL statement being sent
• supplied with a dbMonitor which will show each SQL command sent, including parameters and time taken – just drop a TUniDBMonitor component on your datamodule and set it to active to allow this functionality (dbMonitor must be running prior to running your application).
• it has far more versatility than DBExpress including:
• ability to do SQL batch scripting to create and delete tables.
• map data types – this can be particularly useful when using persistent fields and different database drivers
• encryption functionality
• assign table update SQL statements – although not needed if using TClientDatasets
• stored procedure call generator
• improved transaction control
• ability to set a server table lock mode for each TUniQuery
• each UniDAC driver has server specific options which can be set and these as well as the UniDAC driver are compiled within your application
• ability to use other DevArt drivers such as SDAC if you need even more control over SQL Server or you wish to access SQL Server Compact Edition.
• Disconnected Model with automatic connection control for working with data offline
• Connection timeout management
• Ability to search for installed servers in a local network
• Local Failover for detecting connection loss and implicitly reexecuting certain operations
• it seems fairly simple yet versatile

I attended their World Tour presentation in Melbourne today and this post is to briefly inform of the new features it brings.

Windows 8 support:

• easy VCL or FireMonkey form conversion to Windows 8 “Metro” style
• ability to compile Windows 8 Desktop applications (32bit or 64bit) in either Delphi Object Pascal or with C++ (although 64bit C++ compiler will be in Q4)
• new Windows 8 GUI “Metropolis” components such as MetropolisUIListBox
• Office 2013 styling
• Live Tiles WinRT support (but no WinRT application Delphi compiler as yet – this is coming, although you can compile WinRT apps using Delphi Prism and .NET via Visual Studio 2013)
• video playback utilises DirectShow
• support for gyrosensors, location services, etc
• support for Surface Pro and Slate tablets
• “Fat Finger” touch ready
• the “Metropolis” Win8 Metro GUI-style Desktop apps can be used on Win XP, Vista, Win 7 or Win 8 and work as touch-enabled apps thanks to Delphi gesture control functionality

Mac OS X Mountain Lion support:

• FireMonkey components automatically can detect and be optimised for pixel-perfect display on either Retina or non-Retina displays in the same binary executable
• video playback utilises Quicktime
• non-client area FireMonkey styling
• Mac Apple store compatible

Revamped Firemonkey framework:

• vector based, cross platform FireMOnkey framework was introduced in Delphi XE2
• the framework has been revamped in XE3 and is now called FireMonkey2
• it has been simplified via adding Visual Live Bindings, wizards, and support for anchors, layouts, non-client area styling, audio/video controls, actions and action lists
• Mac OS Retina display optimised
• a new component TPrototypeBindSource allows one to automatically generate a virtual dataset complete with data to link to to assist with mock up application development without need to create an actual database, and this component can also be used to create Live Bindings to custom classes.
• TDatasource is no longer needed, just link a BindSource to a dataset such as TClientDataset

New Visual Live Bindings:

• makes creation of Live Bindings far easier – just drag and drop
• ability to group various Live Bindings together into a “layer” which allows simplification of the visual appearance of these by optionally “disabling” other layers to make the layer you are working with easier to see.
• layer data is stored in files with extension .vlb
• seems the Visual Live Bindings functionality can only represent one form at a time?
• improved dataset lookup support
• can be used in VCL or Firemonkey

New HTML5 Builder:

• a totally revamped IDE of what was formerly RadPHP
• visual design of HTML5, CSS, javascript for client side, while using PHP scripting for server side web apps
• utilises jQuery technology
• deployment to mobile devices via PhoneGap services
• “Phonegap takes your generated html, javascript and css files and injects it into a real .exe file for both Android and iOS. This real .exe file creates it’s own browser instance, puts the browser in full-screen – and disables the security restrictions that public browsers impose on you. Once wrapped, you can create persistent (non cached) databases beyond the usual 5 to 10 megabyte limitation.”
• extensive code completion and help
• embedded multimedia playback in web browsers
• as I understand, this module does not allow one to program in Object Pascal while the compiler generates javascript so it will be interesting to see how this compares with IDE’s which generate HTML5, javascript from Object Pascal code such as Smart Mobile Studio (costs ~$450)

“Mobile”:

• there will be a new, separate software package for compiling native mobile apps for iOS, android, Blackberry, and Windows Phone 7 called “Mobile”
• this can be purchased and used separate to Delphi, or it can be added into the Delphi IDE as an optional add-on
• it is NOT included in RAD Studio XE3 pricing!
• it REPLACES the Delphi XE2 mechanism for compiling mobile apps which relied upon FreePascal and compiling in XCode
• the new mechanism is MUCH easier to use and does not require external management
• allows same Object Pascal code to generate native iOS, Android apps
• new Interbase ToGo database can be deployed to mobile devices as an alternative to SQLite
• Datasnap compatible
• SQLite driver for DBX
• supports device hardware such as gyro, GPS, camera and accelerometer
• mobile device form designers

Delphi XE3 is a very timely product launch which will leverage the new requirements of Windows 8, and Mac OS Retina displays whilst significantly extending and simplifying cross-platform and mobile application development with tools such as FireMonkey and HTML5/CSS/javascript apps.

This will be a must buy version for those interested in such application development.

If one uses the obvious Password=xxx;User Id=Admin you will get an error “Workgroup Information file missing or file is in use by another user”.

The ADOConnection will return an active connection is using the following connection string but in Delphi 2007 I am still getting an error on trying to read the file “Could not decrypt file”.

So here is the Connection String which will open the connection successfully in Read Only mode:

Provider:=Microsoft.Jet.OLEDB.4.0;Data Source=C:\temp\MyExcel.xls;Mode=Read;Extended Properties=Excel 8.0;Jet OLEDB:Database Password="xxx";

It appears that “Could not decrypt file” error is due to a well known limitation of the Jet OLEDB 4.0 engine in that it always returns this error on trying to read a password protected Excel file even if passwords are known.

The hack around this is to open the file in Excel first in full read/write mode BEFORE opening the TADOConnection – just opening it in READ ONLY mode in Excel WILL NOT work!

This is not only an issue in Delphi but in any application that uses Jet 4.0 OLEDB engine.

Of course, another solution is to use COM OLE automation such as:

• CreateOLEObject method – see here

Excel 2007 and higher files (.xlsx):

If you are dealing with .xlsx Excel 2007 or later files, you cannot use the Jet engine, but you can use the ACE OLEDB driver:

• ACE 32bit OLEDB driver if 32bit Office is installed:
• Provider := Microsoft.ACE.OLEDB.12.0;Data Source="C:\temp\MyExcel.xlsx";Extended Properties="Excel 12.0 Xml;HDR=YES;“;Jet OLEDB:Database Password=”";
•  ACE 64bit OLEDB driver if 64bit Office installed and 64bit ACE installed:
• Provider := Microsoft.ACE.OLEDB.14.0;Data Source="C:\temp\MyExcel.xlsx";Extended Properties="Excel 12.0 Xml;HDR=YES;“;Jet OLEDB:Database Password=”";
• NB. YES you read correctly, that is Jet OLEDB:Database Password=”"; and NOT ACE OLEDB:Database Password=”"; !!! AND strangely enough, you can connect to a password protected file without supplying a password at all BUT, whether or not you supply a password, the password protected Excel file MUST be already open in full edit mode within Excel first!
• NB. to install ACE 64bit on a machine which already has ACE 32bit installed, use command line: AccessDatabaseEngine_X64.exe /passive
• to connect to Excel 97-2003 .xls via ACE use Extended Properties=”Excel 8.0;HDR=YES;”
• to connect to Excel 2007-2010 .xlsx via ACE use Extended Properties=”Excel 12.0 Xml;HDR=YES;”
• to connect to Excel 2007-2010 .xlsm via ACE use Extended Properties=”Excel 12.0 Macro;HDR=YES;”
• to connect to Excel 2007-2010 .xlsb via ACE use Extended Properties=”Excel 12.0;HDR=YES;”
• if you get the error “could not find installable ISAM”, you have probably made an error with the connection string.
• unfortunately, if the Excel file is password protected to read, you will get an error “External table is not in the expected format” unless it is already opened in Excel and user has edit rights to the spreadsheet! So we have the same old situation as with the Jet OLEDB provider!
• and don’t bother trying Password=”xxx”;User ID=Admin; as additional parameters, because as soon as you add a value for password, you get the same old Jet issue of “The workgroup information file is missing or opened exclusively by another user”.

Delphi Object Pascal or C++ generated DataSnap middle tier data servers which run on a Windows server and allows the following thin clients to connect to it:

• Delphi Object Pascal or C++ VCL WinForms clients compiled for either Win32 or Win64
• Delphi Object Pascal FireMonkey compiled for native client application for any of the following platforms:
• Win64
• Win32
• Mac OS X
• iOS
• and in 2012, Linux and Java for Android
• via Mobile Connectors:
• Eclipse compiled java client for Android
• XCode compiled iOS client for iPad, iPhone
• Blackberry client
• Windows Phone 7 client
• isapi.dll web client hosted on a Windows web server
  
• RADPhP web application hosted on a web server (requires the DataSnap server to be a REST application)
• RADPhP mobile application packaged for mobile devices via PhoneCap
• .NET client created using Delphi Prism (REMObject’s Oxygene) Object Pascal for .NET running in MS Visual Studio
• ASP.NET web database application created using Delphi Prism (REMObject’s Oxygene) Object Pascal for .NET running in MS Visual Studio.
• Java client created using REMObject’s Cooper project – Object Pascal for java running in MS Visual Studio (in development)

Third party REMObjects is extending its Hydra technology to allow FireMonkey plugins to work on VCL Winforms, and vice versa, as well as WPF plugins to work in FireMonkey apps and vice versa – see here.

RADPhP web database application using MySQL database.

This post I will explore the FireMonkey aspect of Delphi XE2 a bit more deeply.

Vector-based architecture features and implications:

• Firemonkey architecture is presumably a significantly enhanced non-VCL successor to Kryukov’s KSDev vector-based VCL components including VGScene, DXScene, ImageFX and his iOS compiler, for which Embarcadero acquired the IP (apparently in Jan 2011 when further development of his VCL components was ceased, and would explain why the Delphi community was taken by surprise with the recent announcement of FireMonkey).
• allows 3D modeling with all computing work performed by the device’s GPU (thus 3D features currently will not display if remote desktop or Citrix environment)
• allows assigning data points on a 3D model which can then linked via the new LiveBindings functionality to a source data, thereby enabling live 3D charting, etc
• can import various 3D models such as 3ds or Collada, with potential to add more support later.
• full zoom in and out capability without image degradation which means controls look good even on small devices when zooming is applied
• ability to apply 3D effects and filter effects to forms or components, thus one could create a page turning effect potentially.
• a critical difference to other vector based frameworks such as Abobe Flash and Microsoft’s WPF (an XAML DirectX .NET based technology with data bindings, upon which Silverlight is built), is that Apple allows FireMonkey applications to be added to their iTunes app store and thus made available for use on iPhones and iPads (ie. it is FPC-compatible).
• when compiled to a Windows platform, it utilises Direct2D and Direct3D, when compiled to Mac OS X or iOS, it utilises OpenGL.
• it is currently designed for native applications (ie. running independently of any web browser) and not for Rich Internet Applications (RIA) within web browsers (as does Silverlight or Air), and is not specifically targetting gaming development.

FireMonkey components:

• does not use Windows messaging and thus does not play well with visual VCL components in the same application, thus avoid them, BUT one still uses TDatasource, TClientDataset, etc.
• source code included – 99% is Object Pascal code with only a small section of non-pascal GPU code
• components designed to make migration from VCL as simple as possible by keeping similar naming and properties where possible but obviously events that take Windows messaging parameters had to be changed.
• new LiveBindings functionality (which also is now on VCL) means almost any property of a control can be unidireectionally or bidirectionally linked to a source – be it a form variable or TDatasource.dataset field, or other control parameter, this also means, some properties such as position x are no longer integer but Double.
• TFmxObject = class(TComponent);
• any object can contain other components to make it versatile and very easy to create customised objects
• just drop a component onto another component and it will become a child of that component – need to take care in the IDE when dropping components onto a form!
• heavily dependent upon interfaces
• IControl handles focus, mouse and keyboard events, implemented by TControl and TControl3D
• IRoot is interface to top-level containers and is implemented by TCustomForm
• IScene is the container for 2D objects and is implemented by TForm and TCustomLayer3D
• IViewPort is the container for 3D objects (and requires a GPU), and is implemented by TForm3D and TViewPort3D
• GPU-based shading filters which can be applied to bitmaps, forms and controls to give Photoshop-like effects
• new Animation functionality which allows one to modify a property value over time and thereby create changing colors, changing position, etc.
• new Styles is a CSS-like functionality which allows dynamic skinning with ability to save, load and modify at run time to dramatically alter the appearance of the application.
• new StyleBook is a container for styles and provided styles include Win7, MacOSX, etc, but of course one can create their own styles.

Live Bindings:

• available in VCL as well as FireMonkey and in effect makes ALL components and their properties data aware if you wish – very versatile and quite different to VCL’s data-aware approach which is not available in FireMonkey.
• can specifiy unidirectional or bi-directional links which have read/write capability via use of expressions
• a binding consists of 4 aspects:
• source object – this may be a TDatasource.dataset.field or a form variable or component
• source expression – a string which can be edited at runtime. For example, the name of the source property value you wish to bind to such as DisplayName if source is a TField
• control object – this is the destination object that you are binding to.
• control expression – a string which allows one to format the bound data for display, etc. and to specify the control property value which will be linked eg. label.text
• bindings are stored in TBindingsList, and also allow you to register methods available to be called from the expression strings. The expression evaluation engine also accesses the RTTI.
• one also needs to set a scope for the binding and this may be done automatically and uses TBindScope and TBindScopeDB (if linking to a TDatasource)
• instead of TDBNavigator, there is a TBindNavigator which links to a TBindScopeDB or a TBindScope.
• LiveBindings introduces wonderful new versatile opportunities (eg. you can bind to any component property and even to points on a 3D model) but does introduce a significant potential for runtime errors as the expression strings are no longer part of the compiler syntax mechanism, and particularly, if you change the name of a control or variable during refactoring and forget to change it within the expression, or just do a typing error, you will not get a compiler error but a potentially difficult to detect runtime error which may or may not create an exception.
• to create a LiveBinding on a form control, just click on the LiveBindings property of the control and you will have the option of creating one manually or choosing “Link to DB Field” which will automatically place the LiveBinding comonents on the form, and will display all TDatasources and their fields for you to select a field to bind to.

Cross-platform RTL support:

• TFormatSettings in SysUtils
• TOSVersion
• TZipFile in System.zip for crossplatform zip/unzip of files – now this will make life much easier!
• TLoginCredentials
• TPointF

Cross-platform debugging:

• this has been simplified – one copies the Embarcadero Platform Assistant to the target machine or virtual machine, specify port and optionally password then just run it.
• within Delphi IDE, define a remote profile specifying IP address, port and optionally password and remote paths.
• Run with Debug

Cross-platform development limitations:

• platform specific functionality obviously is not available for cross-platform compilation eg. Windows messaging (and thus the VCL), COM, menus (not available on iOS), OS API’s, MS XML transforms, etc
• whilst many GUI applications MAY be applicable for use as is across multiple platforms, the reality is that you would probably wish to have a GUI that is optimised for each platform, and this too is obviously not only possible with FireMonkey, but the best approach for many applications.
• presumably one could use compiler directives to access different API’s or to use COM for Windows compiles, or access iOS camera for iOS compiles.
• issues with Free Pascal for developing iOS apps – see here.

Current limitation issues which will almost certainly be addressed by XE3 release in late 2012:

• cannot compile to Linux, Android or Blackberry (but there are java based Datasnap client solutions for these platforms in the interim)
  
• no Windows 8 specific support as this has not yet been released by Microsoft.
• no customisable gesture support as is currently in the VCL, but usual gestures such as those on an iPad will work as they do normally without programming.
• compilation to iOS is only Object Pascal (not C++ yet) as it relies upon compilation using FreePascal (and thus certain features such as Generics, Anonymous methods are not supported), and then requires one to use Apple’s xCode IDE to do the final compile – but at least one can debug and edit the Object Pascal code within xCode and changes made within Delphi are automatically visible in xCode without having to go through the FreePascal again.
• iOS compile requirements:
• Mac Snow Leopard on an Intel Mac
• iOS SDK with developer subscription (4.2, 4.3)
• xCode 3.25 or 3.26 to do the final compile
• installed official FreePascal 2.4.4 binary required to build FPC 2.5.1
• if using virtual machine on the Mac such as VMWare Fusion, ensure you save your project to a shared folder that can be accessed by xCode
• once project saved in Delphi, use a command line utility to export to xCode files (in a subdrectory)
• then run xCode in OS X and open that project in the xCode subdirectory and compile, debug or run on a connected physical device or an emulation of the device
• your original object pascal code will be accessible, debuggable and editable within xCode!

Development machine:

• It would seem for cross-platform development, the preferred environment may be Mac OS X running Delphi within a 64bit Windows VMWare Fusion virtual machine.

• This would then allow running Apple’s xCode on the same machine and allow all debugging to be performed with the one computer.

Here are a few of the new features in XE2:

64 bit Windows compiler:

• for most Win32 projects, just select compile to Win64 and you have native 64bit Windows executable or DLLs!
• if your project uses 32-bit assumptions, then these will need to be addressed, but otherwise it should just work.
• NB. NativeInt, NativeUInt, pointers, indexes to dynamic arrays, tag properties (now nativeInt) are 64bit
• Use your same source code and project files – just select an additional platform to build for in the project window
• Use the same Windows API calls in your code, although Microsoft have renamed some (eg. SetWindowsLong is now SetWindowsLongPTR)
• Use the same Runtime Library classes and functions
• Use the same VCL components and non-visual components
• new compiler directives include Win64, CPUX64
• can only access 64bit versions of dlls, ActiveX controls, bitmaps and COM objects (eg. 64bit MS Office will only work with 64 bit exe’s and vice versa)
• Win64 now ignores register, pascal, cdecl, and stdcall, so these are ignored in 64bit compilations.
• No Extended type
• issues with assembly code, SHL and SHR

New FireMonkey GPU framework for NATIVE deployment to Win32, Win64, OSX, iOS and Android:

• 1st the bad news – to convert your existing projects, you will have to migrate all your VCL-based code and components to FireMonkey components as the two are not compatible in the same project (because it does not directly use Windows messaging like the VCL does), and instead of data-aware components as in VCL, we now have Live data bindings for all components (these are also now available in VCL)
• Now, the fantastic news:
• awesome 2D and 3D rotatable, visual forms and components with enormous potential for native GUI apps
• you can apply the Gaussian Blur filter on your form at a strength you deem appropriate when a modal form is activated in front of it
• improved animations of visual controls
• compatible with TClientDataset and DBExpress components
• NATIVE deployment as Object Pascal code to target platforms including iOS and thus satisfies Apple’s iTune apps requirements
• Create a single application and target both Windows and OS X
• the framework makes extensive use of interfaces to establish contracts, not inheritance
• it is not managed code like .NET nor does it use AIR, Silverlight, HTML5 or CSS for its functionality but native code

Enhanced DataSnap DBExpress functionality:

• DBExpress ODBC driver
• new mobile and cloud connectivity in RAD Cloud – Microsoft Azure and Amazon support
• supports https
• new Datasnap server functionality includes client connection information and management of the connection from the server with ability to limit number of requests per connection, and ability to detect connects, disconnects, and to forecfully disconnect clients.
• DataSnap clients can be created for nearly every common device natively via FireMonkey although Linux, Android and Blackberry devices currently are limited to using java Datasnap mobile connectors, while Windows Phone 7 devices are limited to using C#/Delphi Prism Datasnap mobile connectors.
• one creates an Android Datasnap client in Delphi XE2 by creating a REST application and ticking the mobile connectors option which adds a DSProxyDispatcher component which will generate project java files such as DSProxy.java which can then be imported into Eclipse IDE for packaging as an Android app.

Enhanced VCL functionality:

• the VCL is NOT being made redundant as it is needed for Windows specific applications (eg. using COM, etc) and backward compatibility
• new functionality includes option of using the incredibly versatile LiveBindings functionality (see next post on FireMonkey) and new VCLStyles which allows a different mechanism of skinning to FireMonkey as it allows the use of a vsf file to be loaded at runtime, or added to the executable in Project options application appearance section, and then allows use of TStyleEngine and TStyleManager to set styles or load from file, but these styles are not applicable to menus, popupmenus or ribbons.

New RadPHP functionality:

• rich jQuery mobile components
• Create mobile-optimized web applications and standalone apps for iOS and Android devices using RadPHP – PhoneGap wizard allows packaging your application by creating java files for import into Eclipse java IDE, selecting a target platform (eg. Android v2.2) and running in the emulator before uploading to the Android store.
• Create mobile optimized web applications that work on all types of mobile devices with elements that behave similar to native mobile apps.
• Take advantage of touch optimized layouts, user interface elements, and professional looking theming using HTML5, CSS3, and JavaScript on the client and PHP on the server in an easy-to-use and visual way that only RadPHP can offer.
• Using jQuery in RADPHP and a technology called PhoneGap, you can now package up a PHP application and deploy it as a native Android application

Very exciting times indeed!!

You can register for the Australian part of the World Tour demonstrations here – the Melbourne event is next Thursday, the 11th August 2011.

This ease of configuration from the net was one of the reasons that made Skype so popular.

It will be interesting to see what Microsoft does with it now that Google is also entering into the VOIP marketplace with its Google Voice product which uses SIP addresses (SIP technology is now in some of the new mobile phones) – Google Voice is currently only available in the US.

Sun took Microsoft to court when Microsoft tried to add proprietary extensions to Java which was owned by Sun and this ended Microsoft’s desire to use Java.

Microsoft then hired one of the architects of Delphi to come up with its own equivalent of Java – and this was the C# language which became the basis of Microsoft’s .NET technology and Windows Performance Framework (WPF) which was the .NET graphical engine for rendering user interfaces on Windows operating systems.

Microsoft then disgarded its Winforms-based development tools such as MS Visual Basic and forced VB users to migrate to VB.NET which would work alongside C# as a programming tool in the MS Visual Studio suite.

This change of direction pushed most developers to .NET, and away from native compiled Windows applications and also away from Java.

Borland responded by creating a .NET version of Delphi which has now evolved to be Delphi Prism but in the process meant it lost its way, and eventually sold Delphi to Embarcadero which is now again leveraging its power and versatility, particularly with its re-vitalised Win32 native application development which will hopefully soon also be able to create native compiled Win64, Linux and MacOS apps, but also with its relationships with RemObjects and the furthered development of Delphi Prism .NET to include ports to MacOS.

In the first decade of this millenium, the vast majority of Windows application development was targeting .NET and if you were not making .NET, companies would think twice about your product.

In 2007, Microsoft released Silverlight – a C#, .NET, WPF technology designed to compete with Adobe Flash and provide a graphical plugin environment for web browser which would run on other major operating systems including MacOS. Developers again rushed to embrace this new technology which has a lot of nice features but also a few downsides.

In late 2010, Microsoft created an uproar amongst the developer community by its apparent lack of ongoing commitment to Silverlight which although provides the richest client experience on Windows browsers, does not run on the multitude of new devices such as Android. Microsoft and Apple now seem to have abandoned .NET and Silverlight and are pursuing HTML5 and javascript technology as  the future of cross-platform web browser applications. Adobe have created their Wallaby conversion tool to allow Flash developers an easier way to migrate their work to HTML5 given that Flash developed websites are locked out of the Apple iOS devices.

see:

• http://www.amazedsaint.com/2010/10/silverlight-vs-html-5-debate-dilemma.html
• http://www.itwriting.com/blog/3127-microsoft-wrestles-with-html5-vs-silverlight-futures.html
• http://team.silverlight.net/announcement/pdc-and-silverlight/
• http://www.itwriting.com/blog/3921-where-is-microsoft-going-with-its-rich-client-api-microsoft-drops-some-clues-as-developers-fret.html
• http://andrewtokeley.net/archive/2010/09/04/when-should-you-use-silverlight.aspx

This leaves many developers wondering about the future of .NET itself when Microsoft does not actually create any major Windows applications using .NET but rather uses native compiled applications for their better performance.

For instance even though Microsoft totally revamped Office apps in 2007, they did not resort to using .NET to architect these.

Likewise, Microsoft Office is not architected with .NET and has a much better user interface than the browser webmail version which demonstrates the limitations of browser-based rich client application development.

If you follow the arguments currently flying around the web, Silverlight and .NET are just not fast enough for major enterprise-wide rich client major applications, and Winforms is still the preferred technology base for such applications.

I know where this leaves me, very happy that I did not change to .NET and abandon Delphi Win32 and its fast natively compiled Windows applications with full access to Windows API’s and memory management, with potential to have native Win64, MacOS compiled apps in the near future.

Furthermore, HTML5 web client solutions need data driven web servers, and these can be created in Delphi 32, Delphi 64, Delphi Prism .NET or Delphi PHP or C++ Builder, depending on your fancy, either with REST/JSON, SOAP/XML, REMObjects or other messaging and with either Azure, Amazon EC2 cloud, DBExpress, ADO, ADO.NET or ASP.NET data technologies, and all with the same RAD Studio programming tool.

How to manage the different SQL dialects:

• whilst sticking to ANSI-SQL 92 syntax will help, particularly with table joins, data conversion or calculation routines and simple data elements such as current date vary with each database vendor making code re-use a nightmare.
• if you ever plan in supporting multiple vendors such as MS SQL server and Oracle, then you need to consider your application design to factor this in.

How to swap between different database engines:

• DB Express may be fine for many functions, but it has limitations which are not present in Borland Database Engine (BDE), or you may wish to use ADO or other engine technology.
• unfortunately, each engine technology has different programming syntax, and indeed different non-visual Delphi components for the database connection and the TQuery component.
• furthermore, they tend to return different data types, for example DBX uses TSQLTimeStamp while BDE uses TDateTime, while BDE and ADO differ on how they determine which field is a numeric or integer field. This makes using persistent fields problematic.

On my research, there are 5 main Delphi approaches:

The traditional Delphi / MIDAS / Datasnap approach:

• see here for details on how I use this approach
• this requires maintaining separate datamodules for each database engine, and potentially separate datamodules for different vendors unless you write code to manually modify SQL statements dynamically.
• easy to visualise and TClientDatasets work as designed with persistent fields, but not so easy to maintain as you need to remember to add your modifications to each version of datamodule.

The Dimeric Virtual Database approach:

• in 2002, Dimeric Software created a database abstraction technology (VDB) for Delphi 6 to help address the above issues and add extra functionality such as database connection pooling, enhanced transaction capabilities, enhanced control over prepared queries, etc.
• it uses interfaces to abstract the Dephi components such as TDatabase, TDataset and TDatasetProvider but leaves TClientDataset unchanged.
• they support the following database engines BDE, ADO (dbGo), DBX (DataSnap), IBX (Interbase Express), ADS (Advantage database server), DBISAM, and Flash Filer 2.
• it uses a set of “Function Escapes” to convert SQL statements to vendor specific statements on the fly – ie. in your SQL statement you would use [today()] and the VDB will convert this into the vendor specific SQL command to retrieve today’s date.
• they have support for the following database vendors or dialects: MS SQL Server, Sybase, Oracle, Interbase, Informix, MySQL, Paradox, DB2, and MS Access.
• this interface approach is powerful and inexpensive ($US99) but may not be the easiest to use if you wish to use persistent fields in TClientDatasets
• see their website for more details.
• Misha Charrett utilises this technology in his CSI Distributed Application Development Framework which makes developing multi-threaded applications easier – see here. This is freely available for use but does require Delphi 2005 or higher.

RemObjects Data Abstract:

• a more expensive solution (~$US990) which will require you to replace TClientDatasets with their equivalent component as well as all the other non-visual database connection components.
• you will not be able to use persistent fields but all fields on the client side are declared in the classes which means a change in the way you approach programming.
• uses Schema to handle different database vendors
• it does allow for data push functionality
• there is no easy conversion from a legacy Delphi application.
• see here for more details.

kbmMW Development Framework:

• kbmMW is another option which may be considered and new licence for the Professional version is $US478
• they do have a free, limited functionality version without source code but only for the current version of Delphi.
• supports different database backends directly without having to write any code.
• advanced connection pooling on both client to server and server to database, caching of result sets on both client to server and server to database
• can mimic as a SOAP server, a WEB server, a AJAX server, a AMF3 server
• only the Enterprise version supports multiple messaging topologies incl. Peer 2 Peer, Hub/Spoke and Broadcast using Publish/Subscribe based messaging via multiple types of fully developer accessible and configurable  message queues
• supports client side controlled transactions, and supports transactions, even spanning multiple databases.
• supports most database vendors
• Automated datastore/database connectivity recovery on connection loss or database breakdown
• compiled as an assembly, kbmMW can be used, feature complete, from within VS.Net to develop both client and server side code
• a native PHP extension exists for both Win32 and Linux that allow direct access to a kbmMW based application server
• an application server can also be accessed from portable devices via a fully portable native C client, a Compact Framework compatible native C# client, a SOAP interface, or an XML interface (only available in Enterprise version).
• the free version “CodeGear” is available for Delphi versions 2007 and later.
• unfortunately, attempting to install this D2007 version failed with the latest Indy version installed, it presumably needs the Indy version shipped with Delphi 2007 (ie. Indy 10.1). Design package could not load as procedure entry point @Idtcpclient@TIdTCPClientCustom@SetBoundPortMin$qqrxi could not be located in IndyCore100.bpl.  The difference in the Indy source seems to be that the constant for this procedure is now TIdPort:Word instead of integer;
• this is an issue as the CSI framework requires the latest Indy version installed.

ASTA:

• ASTA is another data abstraction technology from the 1990′s
• in Nov 2010, they announced ASTA 4 with Unicode support for Delphi 2009, 2010 and XE.