|Delphi Clinic||C++Builder Gate||Training & Consultancy||Delphi Notes Weblog||Dr.Bob's Webshop|
Welcome to this session about Project Kylix - Native Rapid Application Development for Linux. Before we begin, please allow me to introduce the two of us...
I'm Bob Swart, the speaker at this session, and my "partner" Micha Somers is the one at the keyboard.
In 2000 we both worked for TAS Advanced Technologies, an Inprise Enterprise Solutions Partner, and we are proud to have been invited by Inprise/Borland to give this session on Kylix here today.
In the second half of this session, Micha will give you a live demonstration (or rather a preview) of Kylix. He will show you a working IDE and lots of other nice things. But before we do that, let's first explain what Kylix is, so we all know what we're talking about.
Because we have limited time, we ask you to keep all your questions until the end of this session. Apart from the fact that Micha and I probably cannot answer all your questions (we don't work for Inprise/Borland), it will also delay us, and leave less time to actually show Kylix. At the end, we have a few minutes for questions, and you can always address your inquires to the Inprise/Borland people that are here today, of course.
What is Project Kylix?
The goal of Project Kylix is to produce a high-performance Rapid Application Development (RAD) development tool for Linux. RAD here means component-based, two-way visual development of your user-interface (GUI), database, internet, and server applications. Development tool means a high-speed native Delphi/C/C++ compiler for linux.
Project Kylix should also simplify the porting of existing Delphi and C++Builder applications between Windows and Linux.
So, what will this Kylix RAD tool be like? There are three cornerstones here. The first is Native Code Generation (in the ELF object format); Kylix is a native Delphi Linux compiler and debugger (as we'll see in a moment). The second big thing is the Two-way Visual Development; Kylix as we'll show today will be very much like the Delphi/C++Builder 5 IDE (again, as we'll see in a moment). The last, but by no means least, issue is the cross-platform GUI, database, and web development that Kylix will bring to use in the form of CLX (Component Library for X-platform).
We'll take a closer look at CLX in a moment. First, let's examine...
Kylix Developer Benefits
There are a number of benefits that Kylix brings to developers. First of all, Kylix offers a fast time to market with the component based visual development. Specifically, current Delphi and C++Builder developers can leverage their existing skills and code. A second benefit is the lower barrier to entry. Kylix can simplify complex Linux development, and offers especially a short learning curve for Delphi, C++Builder and Visual Basic programmers (in order to move to the Linux platform). The third benefit is the fact that Kylix will produce high-performance native applications! No byte code, p-code, scripts, interpreters or virtual machines, but native machine code.
What Kylix Brings to Linux
In our view, the release of Kylix will mark an evolutionary step for the Linux world. And it's not even one small step. Delphi and C++Builder developers will be ready (on the very first day) to start writing applications for Linux using Kylix. I know Linux isn't Windows, but Kylix will shield us from a lot of that, leveraging existing expertise, code and skills.
Apart from the Delphi developers, Kylix also brings hundreds of thousands of applications, built in Delphi today, ported with Kylix tomorrow. On the first night that Kylix ships, we'll probably see more new Linux applications than we've seen in the past few months...
And to make all this possible, let's not forget the over 500 third-party tool and component vendors, who've been working with Kylix pre-released since the Kylix Kick Start on March 20th this year.
Kylix will support both Open Source and proprietary development, depending on which model you, the developer, choose. Kylix will fully support GNU General Public Licensed application development.
The Kylix IDE and all applications made with Kylix will operate in both KDE and GNOME desktop environments. Kylix aims to fully support both KDE and GNOME themes (KDE themes will be supported in the first release of Kylix).
Finally, Kylix is not meant for Kernel and device driver development (you should use tools like GCC and Emacs for that); rather, Kylix is about application development.
There are three major releases of Kylix that Inprise/Borland is talking about. The first release will be the equivalent of Delphi Standard and Professional for Linux - that's the Kylix we'll see "live" in a few moments. Michael Swindell, Director of Product Management (RAD Tools) at Inprise/Borland, is still confident that the first release of Kylix will ship before the end of this year!
The second release will be the C++Builder Standard and Professional for Linux. The third and biggest release will be the integration of both Delphi and C++Builder in the Enterprise Studio for Linux. This last edition will also contain the N-Tier middleware and full CORBA support.
Windows/Linux Delphi Comparison
This slide shows the comparison between the Windows and Linux editions of Delphi. On the Windows side, the Delphi IDE and Windows DCC compiler produce a native Windows application (executable). The same is true on the Linux side, where the Kylix IDE and Linux DCC compiler can produce a native Linux application.
On the Windows side, we have the Delphi VCL - written on top of Win32 APIs (of Windows 95/98/NT/2000), the MIDAS and data access layer and of course sockets connections. On the Linux side, we can depict a similar architecture, showing CLX (Component Library for X-platform) - based on Qt, which uses the GUI SubSystem on top of the Window Manager and finally X11 on the Linux Kernel. Apart from the visual side, CLX also contains a MIDAS and data access layer, as well as socket connections.
From a Delphi project perspective, the following slide shows the cross-compatible directions from Delphi to Kylix (i.e. porting applications from Windows to Linux). It is important to note two things here. First of all, existing Delphi VCL source code can be ported - with a little effort - to Kylix CLX source code. Project source code is very easy to port - and should probably require no or little changes at all. VCL component usage can be a bit harder to port, although most VCL components and their properties and events will have an CLX counterpart (with some exceptions of course, I get to those in a moment). If you've programmed native Win32 API calls, then these will be almost impossible to port, and will need to be rewritten in native Linux API calls. This is no less than should be expected, of course.
An important question (for Delphi/C++Builder developers) of course is: what can I take with me? In fact, it's easier to tell you what you can't take with you. And that includes all native Win32-specific things like direct Win32 API calls, OLE, COM, ActiveX, ActiveForms, MTS, and "windows-only" third-party components (so make sure your third-party component vendor is getting ready for Kylix now!). And also the BDE (Borland Database Engine) will not be available on Linux, but will be replaced by dbExpress - the cross-platform data access layer of Kylix.
Let's take a closer look at what happens once we've ported a VCL application to a CLX application. As you can see on this slide, you'd usually spend some effort to port a VCL application to CLX (and not back, because CLX is cross-platform by nature). And that's of course because the VCL is native Win32, while CLX is cross-platform.
Once you have a cross-platform CLX application, you can compile it to a native Linux application using Kylix, and compile it to a native Win32 application using Delphi for Windows. In theory, you should even be able to migrate it to another operating system, should CLX be ported to other operating systems too in the future.
And let's not forget that it is entirely possible to write code that will run with both VCL and CLX.
CLX Cross-Platform Technologies
CLX is the new cross-platform component library (not only visual components, by the way). Note that I say "cross-platform" here, and not "Linux", as CLX is not the "VCL for Linux" as some people might think. Yes, I confirm that CLX will be the class library that will ship with Kylix, but it was made clear from the start that CLX will also be included with Delphi 6, so it is actually the cross-platform component library, and not the Linux-specific component library.
CLX consists of four main parts: BaseCLX, VisualCLX, DataCLX and NetCLX. The BaseCLX can be compared to the system unit, sysutils and some other base types, routines and classes. This will be the core of cross-platform Delphi.
Where BaseCLX is the foundation of the cross-platform CLX, VisualCLX is the GUI part and as such the most difficult to keep cross-platform and virtually identical "interface"-wise. Fortunately, VisualCLX is based on the Qt (pronounce "cute") cross-library component framework from Trolltech, which already runs on Windows and Linux. As such, VisualCLX is build upon Qt, and should have the same cross-platform look-and-feel that Qt already has. In other words: using VisualCLX, you can write pretty portable applications for both Linux and Windows.
DataCLX contains the client data access components, such as TClientDataSet, TDataSource and TSQLCOnnection. The DataCLX components can be used for local (single-tier), Client/Server and N-Tier application development.
dbExpress is the cross-platform data access layer (and will also be part of the future version of Delphi for Windows). dbExpress contains the server-side data access components, and provides the data to the DataCLX components.
NetCLX contains the internet-related components of CLX. Kylix (and Delphi 6) will extend the WebBroker Technology with Apache support. This means we can make web server applications in the form of CGI applications and Apache DSO applications. The Enterprise Studio edition of Kylix (to be released next year), will add XML and DHTML support to NetCLX. Finally, NetCLX also contains support for TCP/IP socket connections
Let's now examine the architecture of Database Applications written with Kylix. First, a local database application, which consist of VisualCLX data-aware component, that get their data from the DataCLX layer, which talks to the dbExpress (Cross-platform Data Access Layer) and finally the native database driver on top of the local database.
If we compare the local database application with a Client/Server architecture, you'll notice that the only difference is that the native database driver now connects to a Database Server instead of a local Database.
For a multi-tier application the only difference compared to a local Database or Client/Server approach is the fact that we now split the client in two tiers: a thin-client, and a middle-ware tier. Communication between the thin-client and middle-ware tier is done using MIDAS and SOAP (Simple Object Access Protocol), and the data is passed in native MIDAS format or XML for example.
And now, without further delay, let's give a big hand of applaus to Micha, who will show you all what you've been waiting for: Kylix in Action!
For more information, you can check out Dr.Bob's Kylix Kicks website at http://www.drbob42.com/kylix and the Delphi OplossingsCentrum (DOC) website at http://www.eBob42.com/doc
Once Kylix is available, we'll have technical articles and white papers on our website, as well as Kylix Clinics and special training sessions, so stay tuned...