Delphi 2009 Reviewers Guide
By: Nick Hodges
Abstract: This document describes the new and current features of Delphi 2009.
In This Article
Table of Contents
Thank you for taking the time to review Delphi 2009. This guide is designed to inform you about the capabilities, features, and attributes of the product so that you can be fully informed when writing your review. The guide is divided into three parts. The first gives a general overview of Delphi 2009, describing its basic purpose and capabilities. This section will be a more high-level overview of Delphi 2009’s features. The second part is a summary of the major new features in Delphi 2009. This part will discuss the things that are the “latest and greatest” in Delphi 2009 – i.e. the compelling reasons for buying an upgrade. The third section will give a more complete description of a selection of the product’s extensive feature set.
General Overview of Delphi 2009
CodeGear Delphi 2009 is a general purpose, rapid application development (RAD) Windows application development tool. It produces native Win32 binaries that execute on x86 operating systems.
With Delphi 2009, developers can build almost any type of Windows binary, including stand-alone executables (EXEs) and dynamic link libraries (DLLs), OCX and COM objects, type libraries, Control Panel applets, Windows Service applications, and console applications. Developers can build client applications with rich, complicated user interfaces, or simple command line applications. They can build database client applications that speak directly to major relational database management systems (RDBMSs), and middle-tier application servers, web applications, web sites and web services, windowed applications, ActiveX controls, and multi-threaded applications for running complex embedded systems. In short, Delphi 2009 can meet the needs of any developer writing any application for Windows. It takes a long time and some very serious effort to reach any “virtual programming walls” developing with CodeGear Delphi.
What is New in Delphi 2009
The main new features of Delphi 2009 include:
- New Visual Component Library (VCL) components, including a complete Office 2007 UI implementation, usually called Ribbon controls, which allow developers to build modern, visually appealing user interfaces for the Windows desktop. In addition, many existing VCL components are enhanced to provide support for new Vista APIs.
- Two major new language features – Generics and Anonymous Methods – that allow developers to express themselves more fully and easily in code. Also included are new RTL classes – lists, collections, dictionaries, stacks, and queues – that take advantage of these new language features. In addition, the multi-threading classes in Delphi 2009 have been updated to include support for passing in Anonymous methods for execution.
- A newly architected multi-tier database application development framework which enables developers to sequester their business rules and data access into a middle-tier application server, and then access that application server with powerful yet lightweight client desktop and browser applications.
- Delphi 2009 is a globalization-ready product. The default string is now a Unicode-enabled type, allowing the developer to build completely Unicode-ready applications. Developers can also easily localize new or existing applications, enabling them to accept data from anywhere in the globe, as well as stretch the reach of their applications to the world.
- New productivity enhancements in the Integrated Development Environment (IDE) that take an already capable product to a new level. Developers can easily manage build configurations, project option sets, and Windows Resources.
These new features will be covered more fully below.
To install Delphi 2009, the following prerequisites must be installed:
- Microsoft .NET Framework 2.0
- Microsoft Direct Access Objects 2.8
- Microsoft Internet Explorer v6.0 SP1
- Microsoft XML Core Services (MSXML) v4.0 SP2
- Microsoft Visual J# .NET v2.0 Redistributable
If you don’t already have the prerequisites installed on your system, the Delphi installer will install them for you.
The .NET Framework is required by the IDE, but note that native applications built with Delphi has no dependencies at all on the .NET Framework.
Minimum System Requirements
The following system requirements are recommended for running Delphi 2009:
- Intel Pentium or compatible, 1.4Ghz minimum (2Ghz+ recommended)
- 1GB RAM (2GB+ Recommended)
- 3GB free hard disk space for Delphi
- 750MB free hard disk space for prerequisites
- DVD-ROM Drive
- 1024x768 or higher resolution monitor
- Mouse or other pointing device
The following Windows platforms are supported for installing Delphi 2009:
- Microsoft Windows 2000 (SP4 or higher and security updates are recommended)
- Microsoft Windows XP Home or Professional (SP3 or higher)
- Microsoft Windows Vista SP1 (requires Administrator rights)
- Microsoft Windows Server 2003 (SP1)
- Microsoft Windows Server 2008
The following needs to be installed on the target machine before Delphi 2009 can be installed:
- The latest service packs and security updates are recommended for all platforms, including both XP and Server 2003.
- Microsoft Internet Explorer 6.0 SP1 or later
- Approximately 3 GB of disk space is required for full installation. The installer requires additional temporary space.
- Pentium or compatible 1.4GHz minimum (2GHz+ recommended)
- 1 GB RAM (2GB+ recommended)
- DVD drive
- VGA or higher resolution monitor
- Mouse or other pointing device
Note: The English version of Delphi 2009 updates Internet Explorer versions earlier than 6.0 with the English version of Internet Explorer 6.0 SP1. If you are running a localized operating system, run Windows Update to ensure that you get the proper localized version of Internet Explorer.
Delphi 2009 has three different editions to cater to different market segments – Professional, Enterprise, and Architect.
The Professional edition of Delphi 2009 is designed for developers who need a general purpose, RAD development tool with limited or local-only database access. The Professional edition includes the full-featured IDE, the Delphi language, and the complete VCL, including the VCL source code. It includes local-only database access to InterBase, MySQL and Blackfish SQL.
The Professional edition also contains a limited version of VCL for the Web -- applications are limited to five connections and stand-alone servers.
The Professional edition is attractive to Independent Software Vendors (ISVs), professional developers without a need for remote database access, and any developer wanting to develop general Windows applications and utilities.
The Enterprise edition of Delphi 2009 is designed for developers who need access to enterprise level data stored in RDBMSs. The Enterprise edition provides native local and remote access to nine different database engines:
- InterBase 7.5.1, 2007 and 2009
- Blackfish SQL for .NET/Java
- Oracle 10g and 11g
- Microsoft SQL Server 2000, 2005 and 2008
- DB2 UDB 8.X
- MySQL 4.0.x and 5.0.x
- Informix 9x
- Sybase Adaptive Server Enterprise 12.5
- Sybase SQL Anywhere 9
In addition, the Enterprise edition includes a full version of VCL for the Web, with unlimited access to application-mode web applications for stand-alone, ISAPI- and Apache-based applications.
The Enterprise edition adds high level modeling support through the Unified Modeling Language (UML). Reverse engineering of class diagrams (further enhanced with two-way code editing for Delphi developers) gives a high level overview of the whole project. Documentation can be automatically generated providing easy way to explore and review projects, and supporting communication beyond the core team of developers.
The Enterprise edition is attractive to corporate developers who need access to corporate data, ISVs who write applications that require heterogeneous database support, as well as consultants and VAR that support Enterprise level developers.
The Architect edition of Delphi 2009 includes everything in the Enterprise version, as well as data modeling and design capabilities from Embarcadero ER/Studio Developer Edition. Embarcadero ER/Studio is an industry-leading data modeling tool which helps companies discover, document, and re-use data assets. With round-trip database support, data architects have the power to easily reverse-engineer, analyze, and optimize existing databases. Productivity gains and enforcement of organizational standards can be achieved with ER/Studio's strong collaboration capabilities.
The Architect edition is of interest to the same developers who are interested in the Enterprise Edition, but who want to do database design and management in a highly productive environment.
Delphi 2009 installs either from a DVD or via download from the web. Installation from a DVD is done the traditional way – the customer inserts the DVD into their computer and runs the install application.
However, for the internet download (or Electronic Software Delivery, ESD), the customer receives a small launcher that, when run, downloads the necessary binaries from the internet and installs Delphi 2009. Additional items are available for download on the Registered Users web page at http://www.codegear.com.
The Integrated Development Environment (IDE)
When Delphi 2009 is run, the developer is presented with the Integrated Development Environment, or IDE. The IDE brings together in a single application all the features that a developer needs to develop applications. Encompassing an Editor, a Form Designer, a Project Manager, a Debugger, and numerous other features that enable developers to develop applications quickly and easily, the IDE allows developers to do all there work in a single environment that ties together all the functionality they need.
The IDE provides a user interface familiar to Windows users. Basic functionality is provided via drop-down menus and configurable toolbars holding tool buttons. Many of the various windows in the IDE are dock-able, allowing a developer to fully customize their working environment. Desktop layouts can be saved. Desktops can be assigned for specific purposes such as debugging. Applications can be run and debugged right in the IDE. Developers can set options for almost any aspect of the IDE and their applications and projects. The entire IDE is designed to be customizable and to enable efficient and fast development.
Writing Code -- The Code Editor
No mere text editor, Delphi 2009’s Code Editor provides extensive support for typing and numerous aids for code creation that greatly enhance a developer’s productivity. The editor is hosted in a tabbed window, so it can open and edit any number of files at once. The Code Editor contains all the productivity features that developers have come to expect:
- Syntax highlighting of code makes it clear what each section of code is – comments, strings, identifiers, keywords, and reserved words are all color coded for easy identification.
- Code Completion provides hints to available identifier names as a coder types.
- With Live Templates, developers can, with a few keystrokes, invoke large chunks of code and fill in the pertinent parts of that code very quickly. Live Templates are simple XML files, so developers can quickly and easily create their own templates. Live Templates are also completely scriptable, allowing developers to do anything they can imagine in the Code Editor.
- Class completion automatically generates implementation stubs for class declarations.
- Refactoring support helps a developer rewrite code without introducing errors to make it more readable and organized.
- CodeInsight produces pop-up windows that give insight into parameters needed for a given routine.
- ErrorInsight provides immediate feedback buy underlining code syntax errors.
- HelpInsight provides pop-up windows right in the editor giving basic documentation and declaration information about any identifier within code.
- Block Completion ensures that all code is properly opened and closed. For instance, when a developer types a
begin and then hits the
Enter key, the corresponding
end is automatically added, ensuring that code is properly formatted without interrupting the developers flow of concentration.
- Navigation throughout code is made easy by “context-sensitive” code. Clicking on an identifier while pressing the Control key will take the developer to the declaration or implementation of that identifier. Using a stack-based model, the developer can navigate back and forth through code. Using simple keystrokes, a developer can move between the declaration and implementation of class methods. Large files can be navigated easily with its support for IntelliMouse scrolling.
- Line numbering provides immediate location information. Bookmarks can be set, allowing the developer to quickly return to specific locations in an application’s code.
- When multiple lines of code are selected the SyncEdit icon becomes available in the margin. Entering SyncEdit mode provides a quick and easy search and replace through the highlighted block of text. While SyncEdit works with highlighted blocks of code, the Rename Refactoring provides a context-sensitive search and replace across the whole project, so that only identifiers that truly refer to the same entity are renamed.
- Macros can be recorded and replayed to execute common typing tasks.
Overall, the Code Editor is designed to make typing code easy, efficient, and effective.
Visually Designing a User Interface -- The Form Designer
When not writing code, much of a developer’s time will be spend laying out forms with components to create a user interface. The IDE provides a powerful Form Designer to do just that. Delphi 2009’s Form Designer looks exactly like a Window, enabling What-You-See-Is-What-You-Get (WYSIWG) layout of forms at design-time. Developers can drag-n-drop components from the fully configurable Tool Palette and place them on the form as desired. Components can be spaced and aligned easily using the Visual Guidelines – colored lines that provide visual cues to spacing between components and alignment with other components as a component is dragged on a form.
Once components are place on the form, their properties can be set using the Object Inspector. Listing all a components properties and events, the Object Inspector allows a developer to quickly and easily manipulate a components appearance, and to attach code to the various events that might occur on that Component.
For instance, with the Object Inspector, a developer can control the position and size of any component. He can add buttons to toolbars, change text of edit boxes, and change the color of the background of a form. In addition, he can cause code to run when certain events – OnClick, OnMouseOver, OnKeyDown, etc. – occur to the component.
The Tool Palette houses all the VCL components installed into the IDE. It includes by default all the standard components that ship with Delphi 2009. In addition, developers can add in components from third-parties.
The Tool Palette is completely configurable. Components can be grouped as desired. They can be easily found using filtered searching. The layout and coloring are user-definable. Components can be selected and dropped on the form either with the mouse or keyboard.
Managing an Application’s Content -- The Project Manager
Applications quickly become complicated with numerous forms and code files. Many applications consist of any number of different binaries and projects. Delphi 2009’s Project Manager enables developers to manage their projects right in the IDE. The Project Manager organizes files and forms into projects, and projects into Project Groups. Developers can create new forms and files, add existing forms and files to a project, and add new projects to a project group. Projects can be compiled and built right in the Project Manager. Files and forms can be opened in the IDE. Projects can be rearranged so that they compile in an order dictated by the needs of the application. Everything that a developer needs to do with regard to managing the files and forms that make up a given application can be handled in the Project Manager.
In addition, the Project Manager can manage multiple Build Configurations on a per project basis. It can also manage, save, and reuse specific option sets to make managing those configurations even easier.
Looking Under the Hood – The Debugger
All development runs into problems. When bugs or unexpected application behavior occur, a developer needs to be able to peer into the inner workings of their application, and see into what is happening as the program executes. Delphi 2009 provides a debugger integrated into the IDE that provides deep access and insight into an application as it runs.
When an application is run within the IDE, the debugger takes over and allows the developer to control the process of execution and to gain access to all information about the entire process. Developers can set breakpoints anywhere within their code, stopping execution. Breakpoints are configurable, and can be set to trigger every time, after a certain number of times, or based upon some condition evaluating variables and functions within the users’ code. An implicit breakpoint can be triggered any time an exception is thrown. Once execution is halted, the debugger will provide access to all information within scope. Developers can set watches to track the value of any variable. They can step into code, executing it line-by-line and inspecting the value of variables at anytime. The debugger displays the current call stack, all loaded modules, and the status of all threads associated with the application. If even more detail is required, the debugger can display a CPU-level view, showing the exact assembly code being executed.
Accessing Data – The Data Explorer
Many applications require access to data. The IDE includes the Data Explorer – a panel in the ID that provides quick and powerful access to database data. In the Data Explorer, a developer can create connections to the RDBMSs supported by dbExpress, Delphi’s database access technology. Once a connection has been created, the Data Explorer can be used to browse a given database’s data and metadata. Once a connection and data is available, connections and tables can be dragged from the Data Explorer to the Form Designer to create data access components on the form.
In addition, the Data Explorer can be used to examine data, and build queries using the built in Visual Query Builder.
The Visual Component Library
While Delphi 2009 can build almost any kind of application, the heart of its strength lies in building windowed client or stand-alone desktop applications. For this, Delphi 2009 provides an application development framework called the Visual Component Library (VCL). The VCL is a class library that encompasses the wide-range of Win32 API’s to encapsulate the building of Windows applications. It is component-based, meaning that it is designed to allow developers to build components that can be manipulated on the Form Designer at design-time.
Figure 7 - A Form with a number of VCL controls on it.
The VCL is the foundation for all Windows application development in Delphi 2009. It provides an encapsulation of a Windows-based window in the TForm class. (By longstanding convention, classes in Object Pascal are pre-pended with a ‘T’). The Form Designer in the IDE provides developers with a “canvas” on which to design a user interface. The VCL wraps up all the standard Windows UI controls in components such as TButton, TEdit, TLabel, TCheckbox, etc. The framework is extended by simple inheritance, allowing the users to easily enhance the IDE with their own components. (As a result, there is a rich, broad community of third-party developers – commercial, freeware, and open source – that provide a wide-range of feature-rich components for VCL developers to use.)
The VCL has proven to be remarkably robust over the years, having been adapted to numerous different platforms. The VCL started out on 16-bit Windows, but was soon moved to the 32-bit world to support Windows 95. It has even been, in the past, adapted to support Linux and .NET.
New Features in Delphi 2009
To a reviewer, the most interesting features in an upgraded product are those that are new to the upgrade. This section will give a look at the features that are new to Delphi 2009 since the release of CodeGear RAD Studio 2007.
Database Design and Modeling
The Architect edition of Delphi 2009 includes a complete solution for designing and modeling databases. Developers can use the included version of ER/Studio Developer Edition to create either entity-relationship or physical models of a database. They can then export that model to any of the multiple databases supported by ER/Studio Developer Edition.
An online demonstration of the features of ER/Studio Developer Edition can be found on the CodeGear Developer Network:
New Delphi Language Features
Generics allow the developer to write code that refers to a type without having to specify the specific type of that type. Often called Parameterized Types, generics provide developers with the ability to write general, or “generic’ classes that operate on a non-specific type. The class use case for generics is a list, where the type of the items contained within the list need not be specified when the list is written.
Figure 8 - A Generic class with constraints declared in Delphi
Delphi 2009 provides complete support for generics, including providing generic methods and constraints on generics. Constraints are the ability to limit a generic type to a specific set of functionality. For instance, a constraint might limit the generic type to only those with constructors or to those that implement a specific interface.
Delphi 2009 also provides new runtime library support for generic lists, collections, stacks, queues, etc.
Anonymous Methods are code constructs that allow developers to pass code blocks as parameters. They are a procedure or function that does not have a name associated with it. An anonymous method treats a block of code as an entity that can be assigned to a variable or used as a parameter to a method. In addition, an anonymous method can refer to variables and bind values to the variables in the context in which the method is defined. Thus, Delphi’s Anonymous Methods are full closure types, as they capture state when code blocks are passed.
Figure 9 -- A code snippet that demonstrates anonymous methods
New VCL Features
Delphi 2009 contains a full implementation of the Office 2007 User Interface controls, or “Ribbon Controls”. Built purely in Object Pascal using existing VCL architecture, developers can use ribbon controls to build modern, powerful, easy-to-use GUI applications with no coding. Because they are built upon Delphi’s powerful TActionManager technology, existing applications can fairly easily be migrated to use this new interface design paradigm.
Figure 10 -- A Delphi form using the Ribbon Controls in the Forms Designer
Additional New Components
Delphi 2009 now provides full support for displaying PNG (Portable Network Graphics) images. PNG images are now supported in the TImage and TImageList components. Developers can display PNG images on their forms, or use them on toolbars, menus, and buttons.
The TCategoryPanelGroup component is a collection of collapsible panels in a single component. Similar to the notion of the “Outlook Toolbar”, a TCategoryPanelGroup can contain any number of collapsible panels, which in turn can hold any number or type of other components.
Figure 11 -- A TCategoryPanelGroup showing three CategoryPanels, two of which are collapsed.
Delphi 2009 now supports a flexible, configurable control hint system. Custom Hints can now be more easily created by descending from the TCustomHint class. Delphi 2009
Figure 12 -- a VCL control displaying a balloon hint.
provides TBalloonHint as a default implementation. All VCL components now have a property called CustomHint which refers to a component that descends from TCustomHint.
Balloon hints can have a title and main text. They also can display images within the hint.
TButtonedEdit is an extended edit control that allows the developer to put glyphs inside itself on both sides of the control. The controls provide events that allow code to be executed when either glyph is clicked.
Figure 13 -- A TButtonedEdit used for searching. The Red X can be used to clear the text box.
Updates to Existing Components
The VCL also contains a number of updates to existing components:
- The TImageList component can now contain any image type supported by the TImage component framework
- TButton has been enhanced to support the placing of images on buttons, including having those images match the state of the button. On Vista, TButton now supports the CommandLink and SplitButton styles.
- TTreeView now supports expanded images – that is, a node can display a different image when expanded or collapsed.
- TListView now supports groups for Vista
- TRichEdit now supports the Windows RichEdit 2.0 specification
- TProgressBar now supports a themed look, the Marquee and Smooth mode styles, and on Vista, the Pause and Stopped states are supported.
- TEdit now supports customizing the Password character, and provide a TextTip property. TextTip displays “hint” text when the TEdit is empty and doesn’t have the focus.
A complete demonstration of the new features in the VCL can be found on the CodeGear Developer Network:
New Multi-tier Database Architecture – DataSnap 2009
Delphi was one of the first development tools to include a multi-tier database development framework. Called DataSnap, it allows developers to build middle-tier application servers that serve data and manage business rules in a single application. The middle-tier is the “sentry” to the database, providing access to the data, and enforcing business rules on the processing and updating of that data. DataSnap also provides a powerful client solution which provides access to the middle tier, as well as a powerful in memory dataset for managing and manipulating data on the client.
Delphi 2009 includes a major update to the DataSnap architecture. In previous versions, DataSnap made use of COM technology. In Delphi 2009, those dependencies are removed and replaced with a powerful yet lightweight implementation called Server Methods. Server Methods allow the developer to write methods that are part of the middle-tier. Those methods are then made available to the client in a seamless way. Developers can call server methods exactly as if the code were executing within the client binary. Server methods can pass as parameters any type from the dbExpress type system, including strings, integers, datasets, datareaders, connections, and OLEVariants. This makes for a very powerful means of passing data between client and middle-tier.
The new DataSnap also provides support for existing DataSnap servers.
New IDE Features
Most Windows applications contain Windows resources: Bitmaps, cursors, fonts, and other data that can be contained inside of a compiled binary. Delphi 2009 now provides a Resource Manager that enables developers to easily add and manage the resources in their projects. Developers can add all of the standard Windows Resource types, given them names, and then extract them in code using the TResourceStream class.
Figure 14 - The Resource Manager
Many Delphi projects include numerous individual projects combined to create a single application. Developers can put together DLL’s, EXE’s, and packages to create a unified solution. Managing all the different projects and code files can be difficult. It can be especially difficult at Build-time.
Figure 15 -- The Project Options dialog with inherited settings and applying an option set
Projects often need to be able to be built in different ways for different purposes. Builds for testing, debugging, field testing, and releasing applications might be necessary. Each different build requires a different configuration and a different set of compiler options and settings. Delphi 2009 provides a flexible build configuration management system which works the same in both the IDE and at the command line.
Delphi 2009 allows developers to create project option sets for organizing and managing build options. Option sets can “descend” from others, inheriting and overriding settings as desired. Option sets can be saved in files and applied to specific projects or other configurations.
Delphi 2009 also features a new Class Explorer. The Class Explorer is built on Delphi’s class modeling functionality and provides the ability see the class structure within an entire project. Developers can choose to see classes in a top-down or bottom-up view. In addition, the Class Explorer can be used to add classes, methods, and procedures to an existing class library.
Figure 16 - The Class Explorer
Globalization is an important theme in Delphi 2009, and to take advantage of the new globalization features, developers are going to want to translate their applications into other languages. Therefore, Delphi 2009 includes updated and improved versions of the Integrated Translation Environment (ITE) and the External Translation Manager (ETM).
The ITE is a tool built into the IDE that enables the developer to easily product translated versions of an application. The ITE allows for the selection of any number of language projects. It then scans the main project and extracts all strings, captions, and text that can be translated. It then provides a tool built into the IDE in which the developer or translator can translate those strings. The translations are then placed into a resource DLL in the proper project. Once the resource DLL is present, it will display the properly translated strings when that project is run.
The ETM is a redistributable tool that can be sent to translators or translation services, along with the output of the ITE. This enables developers to manage easily the outsourcing of the translation of applications.
A demonstration of the new IDE features including Build Configurations and the Resource Manager can be found on the CodeGear Developer Network:
A demonstration of the Integrated Translation Environment and the External Translation Manager can be found on the CodeGear Developer Network at:
Updated and Improved COM/ActiveX Support
Delphi 2009 includes a completely re-architected COM and ActiveX development framework. This new framework is based on a new “Reduced IDL” language which is a subset of the Microsoft IDL specification. It is designed specifically to define COM objects in Delphi. The combination of a RIDL file and an associated PAS file means that COM and ActiveX objects can now be defined purely in text. The two files can then be compiled into a type library file (*.TLB) which is external to the actual project itself. This means that the TLB file is a result of the compilation of the project and not part of the project itself. In this way, Delphi COM and ActiveX objects can be properly managed, merged, and stored in a source code management tool. No longer is the TLB file needed to store information about the COM/ActiveX project.
Figure 17 -- The Type Library Editor editing a *.RIDL file
A demonstration of the new COM and ActiveX features of Delphi 2009 can be found on the CodeGear Developer Network at:
Features That Were New in Delphi 2007
The following features were new in the Delphi 2007 release. All of them, of course, are still present in Delphi 2009.
Delphi 2007 introduced Blackfish SQL Delphi Edition. Blackfish SQL is a managed code, SQL-92 compliant relational database management system. Blackfish is a very flexible RDBMS. It can be used as an embedded database in stand-alone applications, or it can easily scale up to a full-blown enterprise database solution. It can run in-process with an application or web solution, or as a server or Windows Service. Deployment is dead simple, requiring nothing more than an XCOPY deployment including the binaries, database files, and license file.
By leveraging the .NET Framework, Blackfish SQL provides all the capabilities of a full-fledged RDBMS, yet offers the flexibility of scaling from an embedded system all the way up to an enterprise system.
Blackfish can actually be run three different ways:
- As a Windows Service
- As a standalone executable
- As an in-process assembly
An application can connect to Blackfish either remotely or locally. When connecting remotely, the connecting application will use the TCP/IP stack to pass information. When connecting locally, the connecting application will simply bind to the Blackfish assembly like any other.
Upon installation, Blackfish will be installed as a Windows Service, set to automatically run on startup. This will make Blackfish universally available on a developer’s machine. Blackfish SQL uses port 2508 by default.
Additional Blackfish SQL Resources
The release of the Vista operating system brought a slew of new APIs that provide support for the new features in Vista. Delphi 2007 was the first tool to take direct advantage of these new Vista APIs. By wrapping the new features up as VCL components and properties, Delphi 2007 gave developers immediate and easy access to much of Vistas new functionality. Delphi 2009 takes this a step further by adding new Vista API support into many of the components in the VCL.
Of course, only applications built with the Vista support will only function completely as expected on Vista. When run on an XP or Windows 2000 machine, those Vista-specific features will “degrade gracefully” and appear as the basic functionality of XP.
Delphi 2007 introduced support for the Windows Aero interface. The VCL adds properties to
TForm that create “glass” frames around the edges of a
TForm. Native Windows developers can thus take advantage of this feature in their native applications. Implementing it is as simple as setting the
Enabled property to True. Developers can set the width of the glass frame around the outside of the form, or even set the
SheetOfGlass property to
True and have the whole form be “made of glass”.
If an application uses the glassing effects and is run on non-Vista systems, the glassing effect does nothing.
The new Vista operating system also enhances the standard dialogs that ship with the control set of the operating system. The VCL encapsulates these new dialogs in the
TTaskDialog components. These components encapsulate the functionality provided by the new Vista dialog controls, making it very easy for developers to incorporate them into their applications.
If an application uses these new dialogs is run on a non-Vista system and invokes the new dialogs, a special exception will be raised, as this functionality is only supported on Vista-based systems. Developers can check for this and invoke the correct supported behavior for the running operating system.
AJAX and VCL for the Web
Delphi 2007 included a new entrant into the VCL family – VCL for the Web. Based in the IntraWweb technology from AtoZed Software, VCL for the Web allows developers to build web applications (as opposed to web sites) in the same way that standard Delphi clients are built. VCL for the Web is a component-based technology that works very similarly to VCL for Win32. Developers drop components on a form, set their properties, and design web pages just like normal VCL forms. However, when the application is run, it runs in the browser.
VCL for the Web is the first and only tool specifically geared towards creating web applications as opposed to websites. It allows you to build web applications faster and easier than any other tool on the market. Based on a powerful HTML rendering engine, VCL for the Web allows developers to design web applications in the same way as they would normal Windows applications. Using a drag and drop approach, developers can drop controls on forms (which can be thought of as a combination between HTML pages and forms), create events and set properties.
An online demonstration of VCL for the Web can be found on the CodeGear Developer Network at:
Database support and component-based access to data have been at the core of Delphi’s feature set since the very beginning. Continuing that long premise, Delphi 2007 included a new, underlying data access architecture called dbExpress 4. Completely backwards-compatible with dbExpress 3 at the component level, dbExpress 4 is a complete re-architecture of the VCL’s database access layer to provide a single-source, unified means of manipulating data.
dbExpress 4 greatly simplifies the process of building database drivers, thus providing VCL developers with access to a broader range of database servers. Written entirely in Object Pascal, dbExpress 4 provides cross-platform development between native and managed code, complete with connection pooling and command tracing. In addition, it opens up to developers a delegate model that allows them to hook into the data access process and provide additional functionality to the process of reading and writing data. dbExpress 4 also includes significant performance increases over previous versions.
Also new in Delphi 2007 was a rich set of metadata classes that enable developers to both read and write database metadata for any of the nine supported databases.
dbExpress 4 is an underlying architecture, so users of Delphi 2007 saw little difference at the application level. The dbExpress components – the VCL components used to access and expose data to the VCL data-bound controls – have not changed in any significant way. Instead, the code that lies beneath them has been made more efficient and expandable. While the typical user probably will not see much difference, they certainly will recognize the speed enhancements and broader access to data.
Additional Selected Features from Delphi 2009
The following section discussed some of the many additional features in Delphi 2009 that may be of interest to those reviewing Delphi 2009.
The Integrated Development Environment
Delphi 2009’s code editor is a powerful environment for developing code. It includes numerous features that remove the drudgery of writing code by enabling developers to quickly file the proper method name, write common code constructs using templates, and easily recognize code errors.
Live Templates is a code editor feature that allows developers to quickly and easily write out common code constructs with just a few key strokes. Live templates offer self-describing, intelligent code insertion, and interactive navigation to the variable parts of the template. Live templates allow you to expand small mnemonics into larger code chunks which you can then customize to your needs.
Figure 18 -- A Live Template for constructing a for loop
In Figure 18 above, the developer has invoked the for template by simply typing ‘for’ and pressing the space bar. The template appears, and provides coding entry points for filling out the code template. The developer can move from entry point to entry point using the tab key, filling in the required information as he goes along. The system also provides hints about what is required for each entry point.
Live Templates are simple XML files that describe how the template will work. Thus, developers can easily develop their own Live Templates for specific uses. Live Templates can also take advantage of scripting engines that can perform almost any function at all.
Code Completion is a Code Editor feature that provides the developer with all the information about a class as the developer uses that class, as well as information about identifiers that are declared within the scope of the current code.
Figure 19 -- Code Completion making it easy to complete a complex identifier
Most applications of any significance will contain many identifiers, and often those identifiers will be descriptive and thus sometimes lengthy. Code Completion can make typing such identifiers quick and easy, while at the same time reducing typing errors by ensuring that the correct identifier is entered. As shown in Figure 19, when Code Completion is invoked, it can easily find the identifier the developer is beginning to type. Simply pressing the Enter key will result in the entire identifier being placed in the Code Editor.
In addition, Code Completion can aid in writing code by quickly finding the proper methods and field of a class or record.
Figure 20 – Code Completion listing all the methods for a TButton variable
In Figure 20, the developer has entered the identifier Button1, added the period, and then invoked Code Completion by pressing CRTL+SPACE. As a result, Code Completion has listed all the methods and fields available as part of the TButton class. The developer can then either continue typing for the desired method or field, which would result in the list being filtered accordingly, or he can scroll through the list looking for the desired item. Once the correct item is found, a simply Enter key will add the selected item in the Code Editor.
Block Completion helps improve the structure of code by ensuring that code blocks are always properly closed. For instance, in Delphi, every begin has to have a corresponding end statement. All case statements also require an end. Block Completion ensures that these statements are properly closed without any effort by the developer. If a developer types:
begin<enter key is pressed>
Block completion will complete the code block by adding the end and putting the cursor where the ‘|’ character is, as below:
Error Insight provides a visual cue to a developer that there is a syntax error in the code editor. Functioning similarly to the “red squiggly lines” of a spell checker, Error Insight can recognize and notify the developer of problems in code.
Figure 21 -- Error Insight highlighting code errors
Help Insight provides popup “tool-tips” for identifiers that provide information about the identifier. These tool-tips can be defined in the developer’s code using the “triple slash” (///) commenting style with XML tags. Developers can comment their code and have those comments picked up by the IDE and displayed as tooltip help when the mouse cursor is places over the identifier. The style of tool-tips themselves can be formatted by the developer using Cascading Style Sheets.
Figure 22 -- Help Insight, showing the properly formatted comments and the resulting Help Insight tooltip. Note that the text above the class declaration matches the text in the tool-tip window.
The Visual Design Experience
The Delphi 2009 Form Designer provides the developer with a graphical, event driven development interface. The designer allows for the visual manipulation of components on a form. The developer can drag and drop components from the Tool Palette and lay out a form design, creating a user interface at design-time. Components behave and render very similarly to how they will behave at runtime. Components can be manipulated by the Object Inspector by setting their properties, with the components providing immediate visual feedback to property changes. The designer itself provides valuable visual design aids such as a grid and Visual Guidelines to make the laying out of components of a form a simple and easy process.
Many applications contain forms with numerous controls on them, and as a result, a difficult task facing developers is the alignment of those controls. Often labels need to be properly aligned with the control that they are “labeling”. A well designed form will ensure that controls are properly aligned and not strewn about haphazardly.
Delphi 2009’s Form Designer provides Visual Guidelines that provide indications when controls and text within controls are properly aligned. This allows developers to quickly and easily build forms buy simply aligning controls with the mouse.
Figure 23 -- Aligning labels and edit boxes with the Visual Guidelines
The Visual Guidelines provide three types of alignment indicators (See Figure 23 above). Blue lines indicate proper alignment of the Top, Bottom, Left and Right of components. Magenta indicates the alignment of text elements in controls. And the light grey lines indicate that the controls are spaced properly according to their Margin and Padding properties.
The Object Inspector performs two functions: it displays and allows for the setting of a control’s properties, and it provides a connection between the events that occur to a component and the code attached to those events.
Figure 24 -- The Object Inspector displaying the properties of a TButton component
The Object Inspector is dynamic and automatically displays the properties of any selected control. If more than one control is selected, it displays the properties common to both controls. The Object Inspector indicates properties that have changed from their defaults my making the value bolded. Properties can be sorted alphabetically or by category. In addition, the appearance of the Object Inspector can be completely stylized.
A modeling view can be reverse engineered directly from the projects. This creates a hierarchical Model View where the project classes are presented in a tree, and also can be represented as UML class diagrams. This model and the diagrams can then be used to automatically generate documentation for the project.
Figure 25 -- UML class diagram generated from a Model View
The managing of application projects and the code, files, and other resources that go along with them is a key part of any development tool. Delphi 2009 provides a powerful Project Manager that enables developers to manage the code files, form files, resources, and other entities that become part of a development project.
The Project Manager provides a hierarchical view of projects. The root is a Project Group which can hold one or more projects. Projects within a Project Group can be rearranged in specific order, depending up their dependencies. All the projects in a Project Group can be compiled in the order that they are entered into the Project Manager.
Developers can create multiple build configurations for their projects to control their project optimizations, search paths and other options. Build Configurations can be refined, with specialized variants inheriting options from a base configuration.
Build Configurations can be accessed through the Project Manager and all configurations for a project can be build by a single Build command from the context menu.
Projects options can be saved as Option Sets and shared between build configurations in multiple projects at any time.
The Build Configuration Manager lists all named configurations for all projects in the current project group. It is easy to choose a configuration by name, click ‘Select All’ and then ‘Apply’ to make the desired configuration active for all projects.
Figure 27 -- The Build Configuration Manager with three projects open
Delphi 2009 includes a complete, full-featured debugger. Delphi’s debugger allows the developer complete control over the execution of an application, providing insight all the way down to the machine code being executed. Developers can track the status of any variable, control execution by stepping into or through lines of code. When the debugger is halted on a breakpoint, any variable in scope can be closely and easily examined. The stack trace is available at all times, and generally, debug information for the stack is available, allowing a developer to trace backwards and determine how a particular point or state was arrived at. In short, Delphi’s debugger gives the developer total power and freedom to peer into the workings of a running application when searching for execution issues.
The most common and straightforward of debugging techniques is the use of breakpoints. A breakpoint is a signal that tells the debugger to temporarily suspend execution of your program at a certain point. When the debugger halts code execution at a breakpoint, an application does not terminate or otherwise end the execution of a program. Instead, the debugger suspends execution and allows the developer to peer into the workings and state of the application. Ways in which a developer can view into the state of the application are discussed below.
Figure 28 -- The debugger stopped on a breakpoint with an expanded debugger tooltip.
Debugger watches are references to specific variables within an application that the developer can use to “keep an eye on” a specific item in code. The debugger will continuously track and report back on the status of any given watch variable. Delphi 2009 provides for expandable watches, which all for “drilling down” into the values of complex items that are being watched. Figure 28 above shows a tooltip watch that has been expanded to show the internal information about an object.
The CPU View of the debugger gives you a complete view of your application at the machine code level. With it, developers can peer “all the way down to the metal” in an application, including the state of registers, the actual ASM code being executed, the exact binary code of an application, and the state of the FPU. At this level, nothing is left unrevealed. The entire CPU window is shown in Figure 29, however, the individual panes of the CPU view can be viewed and docked separately.
Figure 29 -- The CPU showing a complete, low level view of an application
Integrated Unit Testing
Test-driven Development (TDD) has become more and more popular in recent years, and unit testing is a major part of the methodology. Delphi 2009 provides support for unit testing by automating the process of writing unit tests for DUnit (DUnit is a Delphi-based library for running unit tests on Delphi code through the VCL language extensions). Developers can designate specific library code for processing by the IDE, and then Delphi 2009 will produce a test project and empty test cases for the public and published methods of the selected classes. If and when additional methods are added to a class being tested, the unit test wizard can recognize the new methods and add new stub methods for those new methods. Thus, developers can quickly and easily produce unit tests for code libraries.
Figure 30 --The Unit Test Wizard gathering information in order to create a set of unit tests for a code library
Refactoring is the restructuring an existing body of code, altering its internal structure without changing its external behavior. The manual refactoring of code has been done since programming was invented, but only in recent years has it been formalized and automated. Delphi 2009 provides a rich set of tools to aid developers in refactoring code automatically.
As an example, the Change Parameter refactoring will quickly modify a method declaration and its implementation block. This feature allows for adding and removing parameters, as well as changing the properties of existing parameters.
To use this feature, select a method, function, or procedure in the editor (either its declaration in your class or its implementation) and select
Refactor | Change Params. Use the Change Parameters dialog box, shown in Figure 31 , to make the changes needed.
Figure 31 - The Change Parameters dialog box
In addition, a large number of pattern-related refactorings are included in Delphi 2009. All the refactorings for Delphi in Delphi 2009 are outlined in the table below:
Moves static methods from one class to another
Creates an interface based on selected methods of a class, and declares that interface as implemented by the given class.
Moves selected class members to a new class that is the parent of the selected class.
Moves selected members to the direct parent class of the selected class
Moves selected members to the direct descendent class of the selected class.
Deletes selected item only if it is not used anywhere in the application.
Replaces instances of a temporary variable with an inline declaration of the literal value.
Moves an existing local variable to be a field on the given class.
Converts a literal expression into a variable declaration with an assignment of the literal expression to the new variable name
Renames a given identifier throughout the project
Declares as a local variable that has been used but no yet declared.
For a selected, undeclared identifier, will properly declare said variable as a field on the given class.
Creates a new method based on the selected code, including passing in any necessary parameter.
Creates a new resource string based on the selected string, and replaces string literal with name of new resource string.
Adds, modifies, and deletes parameters for a given method.
Note that in order to use many of these refactorings, modeling support must be enabled in the project.
The Object Pascal Language
The Object Pascal language has come a long way from its roots in academia. Far from being the teaching language it originally was, Object Pascal is now a full-featured, object-oriented development language. Object Pascal has kept pace with the latest trends and features in language design. In fact, Object Pascal was the first of the mainstream development languages to implement structured exception handling and properties. Using a highlight readable syntax and a simple, straightforward set of constructs, Delphi is an easy to learn, yet extremely powerful language.
Object Pascal is capable of producing both procedure and object-oriented code. It’s a smooth mix of the two coding methods – allowing the developer the best of both worlds. Developers can build and use their own class hierarchy, access and descend from the Visual Component Library (VCL), and create standard procedural code libraries. Delphi has the power to cover the entire range of coding techniques.
Probably the best source of information about The Object Pascal Language can be found online with Marco Cantú’s Essential Pascal (in PDF form).
The Visual Component Library
The Visual Component Library, or VCL, is a full-featured, eminently expandable and powerful component-based class library. Designed from the ground up to be component-based and thus used in a visual designer, the VCL has performed that role admirably since 1995. Along the way, it has made numerous platform changes, including from Win16 to Win32 and from Win32 to .NET.
Delphi provides a simple yet powerful data access model. Based on the VCL class called TDataset, database access is very visual, and very simple to code against. By easily connecting together Connnection components to dataset components, tabular data can easily be made available to the VCL’s data-bound controls. In fact, data can be displayed without writing any code at all.
In addition, by automatically binding data fields to the VCL’s TField descendant classes, developers can easily retrieve and alter data in code with simple to understand code such as this:
CustomerTableCustomerNameField.AsString := ‘Gary Johnson’;
In this way, developers can easily access data either visually or in code with little or no effort. The VCL components provide much of the functionality of accessing and managing data without the developer having to write code.
VCL for the Web
The VCL provides a powerful architecture called DataSnap for developing multi-tier architecture. Employing various communications protocols and a powerful set of components, VCL developers can easily and with little effort create an application server that provides data, and a thin client application that can read and write data to and from the application server.
By utilizing a TRemoteDataModule class, a developer can easily export an interface to data provider controls that can be remoted using HTTP, DCOM, or a sockets connection. The client application can then obtain a reference to that remote data and import it into a dataset descendent called a TClientDataset. Once in a TClientDataset, the client application can then perform all the normal “Create, Read, Update, and Delete” (CRUD) operations on the data as the TClientDataset tracks and caches all changes. The client application can even be completely disconnected from the server (i.e., the “Briefcase Model”), and then later reconnected. Once reconnected, the TClientDataset provides all the code for reconciling the changes made back to the server.
Applications built with Delphi
Delphi is a very popular development platform for ISVs because it provides native development with easy deployment requirements. A number of high profile applications are written in Delphi. These include:
A more complete list of applications built with Delphi can be found on the public Delphi Wiki.
One should note that Delphi 2009 is built using itself. Other CodeGear tools built using Delphi 2009 include Delphi for PHP and Blackfish SQL.
Delphi 2009 Launch Events
As part of the Delphi 2009 Launch, Embarcadero produced 48 hours of online content covering the new features and benefits of Delphi 2009. A complete rundown of the presentations can be found on the CodeGear Developer Network:
CodeRage I Online Conference Presentations
In March of 2007, CodeGear presented on online conference called CodeRage, in which a number of CodeGear personnel and prominent community members gave demonstrations of the new technology in Delphi 2009. Some CodeRage II presentations that may be of interest to reviewers are given below. The links refer to zip files containing Flash presentations of the conference events.
CodeRage II Presentations
CodeRage I was followed up in November 2007 by CodeRage II, an even bigger online even for CodeGear developers. Presentations given in that event the cover features and uses of Delphi are listed below. (Note that these files are ZIP files that contain a Flash version of the presentation embedded in an HTML file.)
Published on: 9/30/2008 5:02:23 PM
Server Response from: ETNASC04