Real Programmers Use Pascal
Real Programmers Use Pascal
by Ray Lischner, author of
In case you haven't heard the news yet, Borland is porting their landmark
Delphi product to Linux. To many professional programmers, this is wonderful
news. Earlier, you may have read
Kylix is Coming!, in
which I introduced the Kylix project and described it in general terms.
Now that Borland has revealed more information about Kylix, I can give you
more details.
Delphi is a rapid application development (RAD) environment, powered by a
modern, object-oriented programming language and an extensible,
component-based architecture. Currently, all this power is available only on
Windows, where it is successfully being used in games, development tools,
desktop applications, and used to drive web sites and connect multi-tier
database systems. This article takes a closer look at Delphi for Linux and its
companion product, C++ Builder for Linux.
Codename Kylix
Kylix is Borland's code name for a large project that involves porting Delphi
and C++ Builder to Linux, working with tool and component builders to make
sure third-party support is in place when the products ship, and getting
the word out that rapid application development is coming to Linux.
Kylix isn't for everyone, though.
For one thing, the main programming language is Delphi Pascal. Just the name
Pascal sends many programmers scurrying for the exits. But don't be too hasty.
This is not your father's Pascal. A far cry from traditional Pascal, Delphi
has a number of modern conveniences, such as:
Object-orientation (single inheritance of classes, multiple inheritance of
interfaces, single root class)
Integer overflow checking
Array bounds checking
Exception handling
ANSI and Unicode strings
Runtime type information
Built-in assembler
Unit-based modular programming
Static or dynamic linking of units
Strongly typed, except when you need latent type checking, which comes in
the form of the Variant type
Multithreading support (TThread class, synchronization, thread-local
storage)
Function overloading
Arithmetic operator overloading
Fast, optimizing, native compiler
In other words, Delphi has everything a programmer needs for modern software
development (with one exception--generic types--but no language is perfect).
Rapid Application Development
The Kylix package contains more than just a souped up Pascal compiler, though.
The integrated development environment (IDE) supports rapid application
development, which means:
Syntax-directed editor
Integrated debugger
Visual design of forms (windows and dialog boxes)
Visual design of menus
Extensible, component-based framework
Rich assortment of visual controls and widgets
Components to integrate with many popular SQL databases
Components for many popular Internet protocols
Commercial and freeware third-party components
Extensible design-time tools for creating:
Apache modules
Simple or complex database applications
Commercial and freeware third-party tools
Extensible IDE
No need to learn a separate extension or scripting language
Still not convinced? That's okay. As I wrote earlier, Kylix is not for everyone.
Don't use Kylix if:
You like to get your hands dirty in the code. If you don't want to click
and drag a component, but would rather write a few hundred or thousand lines of
code yourself, you probably won't like Kylix.
You need to write kernel modules. Kylix does not support the GNU extensions
that the Linux kernel depends on. (In particular, Kylix has a different syntax
for writing inline assembly language.)
You are writing intensive numerical code. Kylix has an optimizing compiler,
but it doesn't optimize floating-point arithmetic.
You have all the free time in the world to spend banging out code.
What Is RAD?
Now you know what Kylix isn't good for. What use is it? Rapid application
development means just that--writing applications quickly and effectively.
Applications can be desktop tools, from games to word processors. They can be
database clients, servers, or middle-tier layers. They can be network clients
such as email readers, or network servers such as web servers.
The "rapid" part of the description means you can use Kylix to write
applications faster than you could with traditional tools, such as gcc, emacs,
vi, and gdb.
The first part of being rapid is the ability to design forms (windows and
dialog boxes) visually. Click on a component, drop it on a form. Select a
component and modify its properties. These features are commonplace, and you
can find them in Glade, KDevelop, and other tools, so it's no surprise to find
this feature in Kylix.
Kylix is much more than a mere GUI-builder, though. It uses an extensible,
component-based framework for widgets, database components, network components,
and more. The framework is called CLX (component library for cross-platform,
pronounced "kliks"). CLX is easily extensible. Already, third-party developers
are writing components to supplement the standard components. Writing your own
component can be as easy as deriving a new class from an existing component.
CLX comes in several parts:
BaseCLX contains the core parts of the component framework. Included are
some simple collection classes (array-based lists), string-manipulation, I/O,
date and time functions, file management, exception-handling, and more.
VisualCLX uses
Qt , TrollTech's GUI toolkit, for graphics and visual controls. (Borland has
negotiated a limited license with TrollTech, so if you purchase Kylix, you
have a royalty-free license to use parts of Qt in freeware, shareware, and
commercial products. You do not need to pay any additional fees to TrollTech
for use of Borland-licensed Qt technology.)
DataCLX uses Borland's
dbExpress to connect to a wide variety of SQL
databases, including Interbase (which is now an Open Source product)
and mySQL. You can use DataCLX in a single-tier architecture (database and
application on the same machine), client/server, or multi-tier architecture.
NetCLX provides components for common Internet protocols, from direct
socket access to TCP to FTP to HTTP. Write clients and servers, including
Apache modules.
Because CLX is extensible, there will be a variety of components from
third-parties. Several web sites (such as
and Torry's Delphi Pages ) host thousands of components that can be added to Delphi for Windows,
and we can expect similar abundance of components after Kylix ships.
Third-party tool and component vendors are already working with early releases
of Kylix to get their components ready.
Components are convenient for many uses. For example, you can drop a POP3
Client component on a form, add a tree widget to display a hierarchy of
folders, a list widget to display messages in a folder, and a text area to
display a single message. To hook up these components, you add event handlers,
which are just methods (member functions) declared in the form's class. Some
event handlers are simple, such as the tree widget's OnChange handler, which
looks up the selected folder, retrieves all the messages to display in the
list widget. Because you have the full, object-oriented power of Delphi or C++
at your disposal, you can make the event handlers as simple or complicated
as you want.
In less than a day, you can have a basic, but fully functional email client.
RAD has a bad rap in some circles because of tools that allow you to rapidly
build extremely limited applications. The authors advertise that you can build
applications with point-and-click ease without writing much code. We all know
that real programming problems require real code.
What makes Kylix RAD especially powerful is that the CLX component framework
simplifies the tedious aspects of application development, without hiding the
power of the language and operating system. If you need to make system calls
directly, you can.
Instead of wasting your time writing code to manage windows and widgets, you
supply the guts of the application: business logic, computation, organization,
or what have you. Kylix is designed for large and small applications. When
writing code, the source editor helps you in many ways:
Color-coded syntax highlighting shows you reserved keywords, unbalanced
strings or comments, and so on.
Can't remember a function name? Start typing, and the source editor shows
you a list of names to choose from.
Can't remember the function parameters? The source editor tells you the
names and types of the parameters.
Source file too big to find things? The Code Explorer shows all the
classes, subroutines, types, and other declarations in the file, making it
easier to navigate large files.
Where is this declared? Select an identifier and jump directly to its
declaration, even if it is declared in a different file. You can also find all
uses of a declaration within a project.
Even if the source editor is missing a feature that you want or need, you can
extend the editor and other parts of the IDE.
Extensible IDE
Sometimes, though, you need more power than a component can provide. Kylix
has an extensible IDE so you can add new design tools. For example, a menu
bar is a component, as is a popup menu. These components, in turn, contain
menu item components. Editing components is a poor way to design menus, so
Kylix has an interactive menu editor that makes is easy to edit menus
visually. Kylix also comes with wizards (as these tools are called) for
designing database applications, web server modules, and more. Because the
IDE is extensible, third-party developers are working on additional wizards,
and you can write your own.
Some tools require you to learn a special extension language (such as Emacs
Lisp). In Kylix, though, you can continue to use your everyday development
language. Extend the Delphi IDE using Delphi or C++ Builder using C++.
You can even extend Delphi with a wizard written in C++ Builder or vice versa,
so third-party developers can use their language of choice and distribute
their products to all Kylix users.
You can extend the IDE in several ways. You can:
add design windows, like the menu editor;
add menu items to the main menu bar and to the various popup menus in
the source editor, form editor, and so on;
add items to the tool bars;
add form and project designers that build new forms, projects, or other
files based on user-interaction;
customize key bindings (although this feature is more difficult than it
should be);
interface with the debugger, form and source editors, and more.
On the other hand, if you prefer command line tools; if you don't want the
convenience of a WYSIWYG form editor; if you like the challenge of locating
and debugging buffer overruns; then by all means, continue to use your
current tools. You wouldn't be happy with Delphi.
C++, Too!
Real Programmers use Pascal, but sometimes you need or prefer C++, so Kylix
will include C++ Builder for Linux. C++ Builder uses the same IDE and
component framework as Delphi, but with the C++ language. To use the Delphi
component framework, you must use Borland-specific extensions to the C++
language. Note that C++ Builder does not support GNU extensions, so don't try
to recompile the Linux kernel with C++ Builder.
If you prefer standards, C++ Builder can compile ISO standard C++ and C, too.
You can compile any application that adheres to the ANSI/ISO standards, and
you will probably find that C++ Builder for Linux compiles faster than
gcc or g++. You also get the advantage of an extensible syntax-directed editor
and an integrated debugger, even if you don't take advantage of CLX and the
interactive form builder, menu builder, and other RAD tools.
Linux and Cross-platform
Kylix will produce native x86 code, producing standard ELF binaries
(programs and shared objects). No byte-code, no virtual machine, no runtime
library, no Windows emulator needed.
The first release of Kylix will not support other hardware platforms. You
will be able to link gcc-compiled object files into a Delphi project, but g++
classes are not binary compatible with Delphi or C++ Builder. Future
releases will probably support additional hardware platforms, as the market
dictates. Perhaps we will see Delphi and C++ Builder on other operating
systems, too.
CLX is portable between Linux and Windows, and is designed to support other
platforms in the future. Thus, Delphi 6 for Windows will also support CLX
(in addition to its native Windows component library, the VCL). Your source
code can be ported without change between Linux and Windows, provided you
avoid system-specific functions (or you can use conditional compilation).
Borland is firmly committed to remaining neutral when it comes to desktops
and distributions. Naturally, they want you to use Kylix regardless of
whether you prefer Red Hat, Mandrake, Caldera, Slackware, SuSE, or what have
you, or whether you use KDE , GNOME, or
just plain old fvwm. The development tool should not dictate end-user
decisions. That said, the first release will favor KDE slightly because Kylix
and KDE both use
Qt . Kylix applications will run on GNOME, but will not take full
advantage of GNOME-specific features. You can expect future releases to
provide better support for GNOME.
The core Delphi Pascal language will not change significantly in Kylix, nor
will Borland's C++ extensions. Most of the reference material in
Delphi in a Nutshell will apply equally to Windows and Linux, except
for a few Windows-specific features. I will post any language changes posted
to oreilly.com.
How Kylix Will Save the World
Or not. Linux currently faces three significant hurdles against wide-spread
acceptance as a desktop operating system: ease of installation, ease of use,
and availability of applications. Kylix can't help with the first, but
it can with the next two.
Why do I use Windows to read my email? Why am I writing this column under
Windows? The simple reality is that many applications are available only under
Windows. I've tried many email and news clients on Linux, but I prefer
my Windows-based application (Agent, if you must know). I've tried numerous
HTML editors, but I prefer Visual Page for Windows. One of the difficulties
facing Linux application developers is that Linux lacks tools for producing
high quality desktop applications.
If you want to throw together a quick and dirty interface, you can use
Tcl/tk. If you need more programming guts behind the interface, switch to
Python and Tk. If you need the performance of a natively compiled
application, though, you must resort to C or C++. Sure, you have some
toolkits, such as Qt and Jx. These toolkits even have basic IDEs. Kylix has
all that and more.
Borland expects to deliver Kylix sometime in 2000. When Kylix ships, its
feature list will read like the to-do list for other Linux RAD tools. For
professional developers and many others, Kylix will be a valuable addition to
the suite of development tools on Linux. Not everyone will want to use Kylix,
and not everyone should. But if you value your time, if you want to use
cutting-edge tools, if you want to make your mark in the Linux application
space, you should take a close look at Kylix.
Post your responses to this articlehere, or read what others have to say!
Ray Lischner is well-known in the Delphi community as an author
and speaker. He wrote
Delphi in a Nutshell, Secrets of Delphi 2, Hidden Paths of
Delphi3, and numerous articles for Delphi Informant, Dr. Dobb's
Journal and other magazines. His conference appearances include the annual
Borland/Inprise conference, and he has spoken to Delphi users' groups across
the country. He also wrote Shakespeare for Dummies. You can reach Ray
