Delphi 97 Product Address

And Delphi has won over two dozen technical awards around the world.

But the award we're most proud of is from Computer World where we won the 1996 Client/Server Development Tools Survey, beating PowerBuilder, SQL Windows and Visual Basic in customer satisfaction. And that was for Delphi 1.0.

What really made Delphi successful is the architecture that we've created of an open, scalable, object-oriented environment. It combines best performance of a native code compiler, the Visual Two-Way-Tools, and the scalable database technology.

We extended the visual capabilities that includes some ground-breaking features as Visual Form Inheritance, Form Linking and an Object Repository. And we added new tools to help with client/server development including a SQL monitor, SQL explorer, and data modules that help you design your applications better.

But what have we done for you lately? Well, we've introduced some new tools that help you create applications for the global market. This includes the Delphi language pack and the Delphi translation system. They help you create these applications to support Danish, Dutch, English, French, German, Italian, Portuguese, Spanish and Swedish applications. So you can easily create applications that are localized for your environment. And it automatically handles the GUI conversion and maintenance of all of the strings in a database.

Many of you have asked about some of the support programs that we offer. We're very pleased to announce that Delphi has received the Back Office certification from Microsoft, and we'll be certifying compliant with NT 4.0 when that's released into manufacturing.

We've also launched the developer certification program. We've increased a number of authorized education centers. We've introduced client/server maintenance. We've extended our premier VAR program, and we've reorganized our Web site to make it easier to get the kind of information that you have asked for. But we're going even further.

Delphi is a family of products. Both Delphi Developer and Delphi Client/Server Suite have been very successful. But we want to continue to make Delphi Desktop even more popular than it is today, so we will have targeted marketing to attract VB users. We've introduced a rebate program on Delphi desktop, and we'll be introducing a new "learn to program" version.

For those of you who are using C++, you'll find a trial version of Delphi is on the CD of BC++ 5.01 to help you try out Delphi. And we're committed to posting a trial version of Delphi on the Web to make it accessible to users around the world to encourage and extend the Delphi community beyond the 450,000 users that we have today.

Now, there's some interesting development trends going on. We've seen massive growth of Windows and, of course, growth of Windows 32. We're entering into a wired world where everybody's connected. If you're not somebody@somewhere.com, it seems like you're nobody@nowhere.com. So we want to make sure that Delphi is a client/server tool that can take advantage of the Internet. Of course, with all this comes increasing application complexity.

Let's take a step back and look at the evolution of the technology that we've seen that you've faced as a developer over the last few years. Going back through the history of the world, back when programming started in the 1867 through the 1990s, the applications that you created were command line and console-based. The tools that you used were integrated development environments and native code compilers, and the programming methodology that we used was to break problems into smaller parts using new structured programming techniques.

Then things got complicated with the increased complexity of the venture of GUI programming, and the tools that were available to you were class libraries. And the programming methodology was to break problems into smaller parts using new object-oriented programming techniques.

The tools that you're using are Rapid Application Development client/server tools where you want to use a programming methodology of breaking problems into smaller parts using new component-based, object-oriented programming techniques.

And now things are getting even more complicated. In 1996 and 1997, you have increased complexity of Internet and distributed applications. The programming methodology: no surprise, break problems into smaller parts. I think we're getting the hang of that one. You need to use new multi-tier technology. And the tools that you'll want to use here, we'll see Anders about that.

So let's look at it from a technical perspective. Today as a developer, you're building Delphi applications. And even if you're building a client/server application, you start off with building a single-tier application on the client. If you're building your own individual application, it works this way also. You'll use tools today such as the UI Builder, VCL, the editor, and debugger. And, of course, you can extend this to be two-tiered to support client/server. This is where we introduced many of the new tools in Delphi 2.0. The latest evolution has introduced a multi tier architecture that adds an application server, and there will be new tools and components that support multi-tier development.

Our vision is to support the rapid development of high-performance, client/server, multi-tiered applications through the enterprise and across the Internet. What I'd like to do now is welcome Anders Hejlsberg, the chief architect of Delphi 97.

ANDERS HEJLSBERG: My name is Anders Hejlsberg, and I'm the Chief Architect for Delphi. I'm very pleased to be here today at the Borland Developers Conference to talk about our future directions for Delphi.

I'm here to talk about Delphi 97 and the new technologies that will be incorporated into our Rapid Application Development tool. I will first give you an overview of our objectives for Delphi 97. Next, I will go into more detail about the challenges of distributed computing. And finally, I'll give you a preview of Delphi 97 and how it supports our golden gate initiative to bridge the Internet and Client/Server world to provide important capabilities to all developers.

Our mission with Delphi 97 is to bridge the Internet and Client/Server architectures to make multi-tier computing easy. Some of you might wonder why the Internet is so different from client/server development today. In fact, its not all that different. Its really an extension of the skills and techniques you already know. Some people have called the Internet "Client/Server done right" because it embodies the best aspects of Client/Server technology in a heterogeneous open architecture that's offers greater performance and maintainability.

Our objectives with Delphi 97 are to build on the core strengths we've established with Delphi. Performance, reuse, RAD and scalability aren't just buzzwords to us, they're the embodiment of what Delphi represents. Namely, provide real solutions to the problems that developers face on a day to day basis. Only now, we want to extend the scope of problems Delphi can deal with to include the fastest growing technology in the market. That is, distributed or multi-tier computing. From our research we have found that over 50% of the Delphi customers create their own reusable components. And many customers create high-performance DLLs in order to combine Delphi code with other tools. Our objective is to continue to increase the reusability of Delphi code by making it the component foundry for all application developers. You will be able to create components in Delphi that are industry standard ActiveDocuments and ActiveX components so that you can reuse them in any application, whether its in C++, Java, Visual Basic, PowerBuilder, Internet Explorer or MS Office. To do this, we will also ensure integrated native support for the MS systems technologies. In Delphi 2.0, we included OLE 2.0 controller, server, automation and COM support. Moving ahead, we will support the entire range of new MS systems technologies. Not just ActiveX and ActiveDocument technologies, but also support for DCOM so that you can take advantage of the evolution of distributed OLE. Distributed computing means a wide range of new challenges which we want to address.

In fact, there are a whole new range of problems that arise as soon as you start extending applications to multiple tiers. You might ask yourself questions like How can I build web clients and servers? How should I distribute my applications? Should I partition the application logic? How do I deal with distributed data and disconnected users? Should I short Yahoo stock? We'll try to give you answers to at least n-1 of these questions.

My talk today will show you how we are addressing these challenges in Delphi 97. As we look at each area, you'll see how Delphi scales to address each of these issues. Let's take a look at how you build client and server applications for the Internet.

Internet Solutions Pack

Because of Delphi's component architecture, compiled code, and full support for the Win32 API, Delphi is ideally suited for writing Internet-aware apps.

For those of you who haven't seen the update release, here you see how we've written an Internet Browser in just 5 lines of code.

We can take a look at an Olympic Web site that lets us order Olympic tickets. Tickets are half off for all of last weeks events.

This new API is called ISAPI, and it allows you to write extension DLLs for the Internet Information Server. Delphi now includes support for ISAPI, and the database parts of the Web Server you just saw were implemented by a DLL written in Delphi. Because Delphi is an optimizing native code compiler, we can take advantage of a direct connection to the Web server using the ISAPI API for faster performance.

Being a DLL, our server of course doesn't have a visible UI. However, Delphi's data modules allow you to design even DLLs visually. For example, here's the data module used by the server. It contains two parameterized queries.

We have also developed new Internet Server components to make it easier to write servers.

These components allow one server application to automatically handle multiple URLs by extending the Delphi event model to associate URLs with event handlers. In addition, you can create Web Modules, much like Data Modules today, only they're optimized for Web server applications. This makes it easier to support state management in your application, automatic connection management, multi-threading of client sessions and so on. That way when you have a complex application, let's say like when you have a "shopping cart" for ordering items on the web, we'll eliminate a lot of the grunt work programming for you. Today we showed the Web server application written using Microsoft's ISAPI interface. However, we've actually developed a higher level interface that combines Microsoft's ISAPI and Netscape's NSAPI. We call it the ISAPTOR, and it will make it so that Delphi bridges between both the Microsoft and the Netscape worlds. So you can write one application server that can support either platform.

Packages

In Delphi 2.0 we made EXEs smaller as well as faster by using new optimizing compiler and improved linker technology. Even so, large applications can still measure several hundred K in size. Many of you asked us about putting Delphi's Visual Component Library in a DLL so that it could be shared among applications. And we've had requests to allow subclassing of components in DLLs. Also, others want to be able to easily switch between different palettes of controls for different kinds of projects. And finally, in the "wired world" that we're in, there's a push to make application deployment more compact and more flexible so that you can easily deploy applications across your corporate Intranet or across the public Internet. Packages enable us to do all these things as well as speed up development. Let's take a look.

Many of you have probably seen the fishfact project. Let me compile and run it.

So, it's about 450K in size because it uses pretty much all of our data-aware controls. With the packages technology of Delphi 97, we can make this quite a bit smaller and more flexible. In order to enable Packages, we simply need to select a new Project Option to enable it:

Now let's recompile and run the application.

Because the VCL library is already in memory, it also loads faster than before. So let's just see the size of the app using packages. It's only 13K. As you can see, there's still room for improvement. You can select whatever packages you want for your application. And you can also create your own custom packages. This allows you to define your own libraries of Delphi components and place them into DLLs. In fact, we've eliminated COMPLIB.DLL, and we now use dynamically loaded packages instead. For example, let me show you how I can dynamically load a package that contains additional components. Notice that the components have shown up on the palette.

One important feature is that you can build and repackage the packages any way you want. For example, you can create your own custom package that contains the parts of VCL you use, along with your own standard components. A package is simply a collection of units. And it can be a small as a single unit or as large as you want, and it's always the same optimized compiled code you're used to with Delphi today. If you'd prefer to compile the VCL into your EXEs, then you can do it the old way too. You really get the best of both worlds here. Another important point is that packages do not in any way change the semantics of your applications. Using a unit from a package is exactly the same as using a linked-in copy. In fact, no source code changes are required and you simply decide at link time. Packages are a good example of the approach we take when building Delphi. We always try to build core technologies so that they benefit as many people as possible and don't cost anyone anything extra. Everyone can take advantage of the greater compile speed and flexibility that packages provide you.

Internet Deployment

As I mentioned earlier, one of the motivations for building packages is to support the distributed applications. For example to use the Internet or corporate Intranet to deploy and update your applications. Whether you're a corporate developer or working on the next killer application, dealing with updates can be a real hassle. The more users you have, the more complex it is. Ideally you want to have a thin client application that is automatically configured and eliminates the many hassles of worrying about client libraries, DLL versions and so on. Last night you saw the Stones & Bones application. Well, rather than having to install the application from floppies, add information to my registry with RegEdit and reconfigure my aliases, I can do all of this using my corporate Intranet. Let's go back to the web site. You see there's a button here at the bottom for getting the latest version of the application. All I have to do is click on the button, and the client application is downloaded onto my machine As I mentioned earlier, our objective is to make Delphi the component foundry for creating reusable ActiveX components for use in a variety of applications. So here's the application. And it now establishes a connection to the corporate database server and queries the distribution database.

So, what you just saw was a 45K application, written with packages, being delivered to my machine through my browser. The idea here is that the first time you request an application, we'll download any support packages you need. But from then on you can just download very small applications which reuse the same support packages. In fact, the button I just clicked is a native code, compiled ActiveX that's written in Delphi.

COM Components

One way to mitigate increasing application complexity is to break up applications into smaller components that interoperate through well-defined interfaces. For example, more and more corporations need to separate the user interface components from the business logic and transaction components. If you want to write pieces of your componentized application in different languages or distribute the app on multi tiers, then you need a standard component model to provide this interoperability: That's where COM comes in. Though COM is an important systems technology to support application partitioning, it takes far too much time to understand and implement productively because it requires an awful lot of manual bookkeeping. It's just like writing your first "Hello World" program with the Windows SDK before the advent of class libraries.

With Delphi 97 we've extended the compiler to support COM interfaces as a standard language type. We automatically manage all of the housekeeping work like calling AddRef, Release, QueryInterface, aggregating objects, forwarding method calls and generating type libraries. We support COM interfaces, dispatch interfaces, and dual interfaces which combine the best of both worlds for flexibility. If you've dabbled in COM then you know how complex these tasks can be. And if you haven't, you'll never have to. Because its now as easy to create a COM component in Delphi as it is to create a regular class. And we even allow you to add Interfaces to your existing Delphi classes to turn them into COM objects. What this means is that you can create components in Delphi that can be reused in C++, Java, JavaScript, ActiveScript, VB, PowerBuilder or anywhere. This is the holy grail of object-reuse.

OLEnterprise

The Stones & Bones application takes advantage of computational functions written elsewhere in the company so we can compare our manufacturing levels to the projected demand based on statistical calculations by the marketing department. When we click the Run Demand button it executes a method of a COM component running as a local COM server. The COM component defines the business rule.

You see the server come app and returns the predicted demand.

OLEnterprise is flexible enough to allow us to move the location of the COM server to a remote machine, while the application is running. We'll start the OLEnterprise Object Explorer to do this. Now we've told OLEnterprise to use the remote version of the COM server running on the application server tier. Now when we click on the Run Demand, we see the COM server is running on this other machine.

Distributed Data Access

Now that we've arrived at a multi-tier application architecture that has UI logic running on the client machine, business rules and transaction logic on the application server tier, and databases on our database servers, we run into what I call the "Impedance mismatch problem". The application server can send queries to the database server and receive result sets in return. However, today there is no easy way for the app server to pass that result set through to the client application. Since communication between the client application and the app server is done through remote procedure calls, there is no datatype or mechanism to support passing an entire result set between these two tiers. You are essentially forced to write code on the application server to take the result set apart one row at a time, put it into an array, and pass it as a parameter to the client application. And once the data is on the client, you then have to reassemble it by putting it into a local table before you can show it in data-aware controls. Then, once the data has been edited on the client, you have to repeat the entire process in reverse. This forces you to write a lot of housekeeping code and to have a full database engine deployed on the client tier. This is the current state of the art. No tool on the market solves this problem today: not PowerBuilder, not Visual Basic. But Delphi 97 does! So let me give you our first preview of Distributed Datasets.

I can retrieve a data set from the application server by invoking a method of a COM component that's running on the server. The COM component in turn executes business logic that retrieves a dataset from the database server, and passes that dataset back to the client.

At this point we have a local copy of the dataset which is entirely disconnected from the server. Now let's edit the dataset locally.

We can ask to see the records that were changed And we can switch back to the full view. Now, when I press the Apply button, we'll remotely invoke another method of the COM object on the application server, passing it a dataset containing only those rows that were changed. The application server in turn can apply business rules to our input, and perform the modifications in a transaction. And the server returns us a change log.

So what are the benefits: Separation of UI and business logic. You can change business logic without affect the client applications. Thin client. Database engine requirement is under 100K. No more client database configuration. Only need to configure application server. Full powered language for implementing business rules. Since you're writing the application server in Delphi you're not restricted to a limited programming language as is the case with stored procedures on SQL servers. Efficiency. Greater efficiency of database server connections and reduced network traffic.

Application Management

OLEnterprise is really just the tip of the iceberg in terms of application management capabilities. Open Environment has a series of tools that provide application management capabilities. These tools support distributed application performance load monitoring, fail-over recovery, security and encryption.

Conclusion

With Delphi 1.0 we built a solid foundation for client/server and desktop development. With Delphi 2.0 we added to that foundation to provide the fastest 32 bit performance, richer object-oriented technology and more mature client/server database capabilities and tools. Today, we're moving into a new era of distributed computing. The same technologies of high-performance optimizing native code compilers and robust object-oriented capabilities that helped tame client/server will now be applied to new problems of distributed application development, deployment and management.