O Delphi na Estrada 2025 está chegando para movimentar a comunidade Delphi em todo o Brasil! Durante o mês de maio de 2025, o Delphi na Estrada vai passar por oito cidades diferentes (Porto Alegre, Chapecó, Curitiba, Campinas, Rio de Janeiro, Teresópolis, Brasília e Fortaleza), oferecendo palestras e atividades de alto nível para desenvolvedores de todos os níveis — de iniciantes a veteranos da linguagem.

Com uma programação diversificada e palestrantes renomados, incluindo Embarcadero MVPs, desenvolvedores de bibliotecas populares, consultores especializados e até convidados internacionais, o Delphi na Estrada promete ser uma experiência única em cada local. Cada cidade contará com temas e profissionais diferentes, garantindo conteúdos valiosos e trocas enriquecedoras.

O que esperar do Delphi na Estrada 2025?​

O Delphi na Estrada traz objetivos importantes para quem vive o desenvolvimento com Delphi:

• Promover a linguagem Delphi: Discutir sua evolução, tendências atuais e previsões para o futuro.
• Compartilhar conhecimentos técnicos: Apresentar técnicas inovadoras, dicas valiosas e ferramentas que facilitam o desenvolvimento.
• Fortalecer a comunidade Delphi: Proporcionar networking, aprendizado e troca de experiências entre desenvolvedores de diversas regiões.
• Conectar especialistas e iniciantes: Criar um ambiente colaborativo para que todos possam crescer e aprender juntos.

Programação e Conteúdo​

Das 13h às 18h em cada cidade, o Delphi na Estrada vai oferecer um conteúdo técnico relevante e inspirador, incluindo:

• A história e a evolução do Delphi: Como a linguagem se desenvolveu ao longo dos anos e o que vem pela frente.
• Técnicas modernas e práticas avançadas: Conhecimentos aplicáveis que facilitam o dia a dia do desenvolvedor.
• Casos reais de sucesso: Exemplos práticos de como o Delphi é utilizado para resolver desafios complexos.
• Dicas de especialistas: Truques e insights para quem quer levar suas habilidades a outro nível.
• Networking com a comunidade: Conheça outros desenvolvedores, compartilhe experiências e faça contatos valiosos.

Onde o Delphi na Estrada vai passar?​

Em maio, o Delphi na Estrada percorre oito cidades brasileiras. Escolha a mais próxima de você:

• Porto Alegre – RS: 12 de maio
• Chapecó – SC: 14 de maio
• Curitiba – PR: 16 de maio
• Campinas – SP: 19 de maio
• Rio de Janeiro – RJ: 20 de maio
• Teresópolis – RJ: 21 de maio
• Brasília – DF: 22 de maio
• Fortaleza – CE: 23 de maio

Por que participar?​

O Delphi na Estrada é uma oportunidade única para desenvolvedores de todas as regiões do Brasil. Além de ser totalmente gratuito, ele oferece:

• Proximidade geográfica: Sem precisar se deslocar para longe, você pode participar do evento na sua própria cidade ou em uma cidade próxima.
• Palestrantes renomados: Especialistas nacionais e internacionais, muitos deles Embarcadero MVPs, trazendo conteúdos relevantes e atualizados.
• Networking: Interação com outros desenvolvedores, consultores e líderes do mercado.
• Conteúdo técnico de alto nível: Conhecimentos valiosos que podem ser aplicados imediatamente nos seus projetos.

Inscreva-se e participe do Delphi na Estrada!​

As vagas são limitadas e a inscrição é gratuita! Para garantir seu lugar, acesse o site oficial e escolha a cidade mais próxima de você:

https://www.delphinaestrada.com.br

Não perca essa chance de aprimorar seus conhecimentos, fazer networking e se inspirar com o que há de melhor na comunidade Delphi!

AWS Simple Storage Service (S3) is one of the most popular services provided by Amazon Web Services. It offers scalable, secure, and reliable cloud storage for all kinds of data, ranging from media files to backups. AWS S3 is designed to store data in "buckets," which are containers that hold objects (files) along with metadata. S3 provides essential features like versioning, encryption, and access control, making it an excellent choice for developers who need a versatile and easy-to-use storage solution.

Support for AWS S3 has been introduced in the AWS SDK for Delphi. This new addition brings the powerful capabilities of AWS S3 directly to Delphi developers, allowing you to interact with your cloud storage from your Delphi applications seamlessly. Whether you need to upload files, list objects, or manage buckets, it's all now possible with the familiar Delphi syntax you know and love.

Key Features of AWS S3 in AWS SDK for Delphi​

• Bucket Management: Easily create, delete, and list S3 buckets.
• Object Operations: Upload, download, delete, and list objects in your S3 buckets.
• Access Control: Manage permissions to control who can access your data.
• Advanced Configurations: Leverage options like server-side encryption and metadata tagging for your objects.

Uploading a File to S3​

This section demonstrates how to upload a file to AWS S3 using the AWS SDK for Delphi:

uses
  AWS.S3;

procedure UploadFileToS3;
var
  S3Client: IAmazonS3;
  Request: IPutObjectRequest;
  BucketName, Content, ObjectKey: string;
begin
  S3Client := TAmazonS3Client.Create;
  BucketName := 'my-bucket';
  ObjectKey := 'TestObject';
  Content := 'Sample Content';

  Request := TPutObjectRequest.Create;
  Request.BucketName := BucketName;
  Request.ContentBody := Content;
  Request.Key := ObjectKey;

  try
    S3Client.PutObject(Request);
    Writeln('File uploaded successfully!');
  except
    on E: Exception do
      Writeln('Error uploading file: ', E.Message);
  end;
end;

Getting an Object from S3​

This section explains how you can retrieve an object from an S3 bucket using the AWS SDK for Delphi:

procedure GetObjectFromS3;
var
  S3Client: IAmazonS3;
  GetObjectRequest: IGetObjectRequest;
  GetObjectResponse: IGetObjectResponse;
  BucketName, ObjectKey: string;
  Reader: TStreamReader;
begin
  S3Client := TAmazonS3Client.Create;
  BucketName := 'my-bucket';
  ObjectKey := 'test.txt';

  GetObjectRequest := TGetObjectRequest.Create;
  GetObjectRequest.BucketName := BucketName;
  GetObjectRequest.Key := ObjectKey;

  try
    GetObjectResponse := S3Client.GetObject(GetObjectRequest);
    Reader := TStreamReader.Create(GetObjectResponse.ResponseStream);
    try
      Writeln('Object Content: ', Reader.ReadToEnd);
    finally
      Reader.Free;
    end;
  except
    on E: Exception do
      Writeln('Error getting object: ', E.Message);
  end;
end;

Generating a Pre-Signed URL​

This section demonstrates how to generate a pre-signed URL for an object stored in an S3 bucket, allowing temporary access to the object:

procedure GeneratePreSignedUrl;
var
  S3Client: IAmazonS3;
  Request: IGetPreSignedUrlRequest;
  BucketName, ObjectKey: string;
  Expires: TDateTime;
  Url: string;
begin
  S3Client := TAmazonS3Client.Create;
  BucketName := 'my-bucket';
  ObjectKey := 'test.txt';
  Expires := Now + 1; // URL expires in 1 day

  Request := TGetPreSignedUrlRequest.Create;
  Request.BucketName := BucketName;
  Request.Key := ObjectKey;
  Request.Expires := Expires;

  try
    Url := S3Client.GetPreSignedURL(Request);
    Writeln('Generated Pre-Signed URL: ', Url);
  except
    on E: Exception do
      Writeln('Error generating Pre-Signed URL: ', E.Message);
  end;
end;

In this example, we create an instance of TS3Client and use it to upload a local file to an S3 bucket. The AWS credentials and region are automatically retrieved, similar to how it is done in the AWS SDK for .NET, from the .aws configuration file or environment variables.

Example: Deleting a Bucket with All Its Objects​

Here’s an example of how to delete an S3 bucket along with all its objects, including different versions of objects. This can be useful when you need to completely remove a bucket and ensure all of its contents are deleted first.

class procedure TS3TestUtils.DeleteS3BucketWithObjects(S3Client: IAmazonS3; const BucketName: string;
  const DeleteOptions: TS3DeleteBucketWithObjectsOptions);
begin
  var listVersionsRequest: IListVersionsRequest := TListVersionsRequest.Create;
  listVersionsRequest.BucketName := BucketName;
  var listVersionsResponse: IListVersionsResponse;
  repeat
    // List all the versions of all the objects in the bucket.
    listVersionsResponse := S3Client.ListVersions(listVersionsRequest);

    if listVersionsResponse.Versions.Count = 0 then
      Break;

    var keyVersionList := TObjectList<TKeyVersion>.Create;
    try
      for var index := 0 to listVersionsResponse.Versions.Count - 1 do
      begin
        var keyVersion := TKeyVersion.Create;
        keyVersionList.Add(keyVersion);
        keyVersion.Key := listVersionsResponse.Versions[index].Key;
        keyVersion.VersionId := listVersionsResponse.Versions[index].VersionId;
      end;
      try
        // Delete the current set of objects.
        var deleteObjectsRequest: IDeleteObjectsRequest := TDeleteObjectsRequest.Create;
        deleteObjectsRequest.BucketName := BucketName;
        deleteObjectsRequest.Objects := keyVersionList;
        deleteObjectsRequest.KeepObjects := True;
        deleteObjectsRequest.Quiet := DeleteOptions.QuietMode;
        var deleteObjectsResponse := S3Client.DeleteObjects(deleteObjectsRequest);

      except
        on DeleteObjectsException: EDeleteObjectsException do
        begin
          if DeleteOptions.ContinueOnError then
          begin
            // Continue the delete operation if an error was encountered.
          end
          else
            // Re-throw the exception if an error was encountered.
            raise;
        end;
      end;
    finally
      keyVersionList.Free;
    end;

    // Set the markers to get next set of objects from the bucket.
    listVersionsRequest.KeyMarker := listVersionsResponse.NextKeyMarker;
    listVersionsRequest.VersionIdMarker := listVersionsResponse.NextVersionIdMarker;
  until listVersionsResponse.IsTruncated;

  var maxRetries := 10;
  for var retries := 1 to maxRetries do
  begin
    try
      // Bucket is empty, delete the bucket.
      S3Client.DeleteBucket(BucketName);
      Break;
    except
      on E: EAmazonS3Exception do
        if (E.StatusCode <> 409) or (retries = maxRetries) then
          raise
        else
          TDefaultRetryPolicy.DoWaitBeforeRetry(retries, 5000);
    end;
  end;
end;

This example shows how to list and delete all object versions in a bucket before deleting the bucket itself, ensuring that all resources are properly removed.

Conclusion​

The addition of AWS S3 support to AWS SDK for Delphi opens up a range of possibilities for Delphi developers who want to leverage cloud storage in their applications. From managing buckets to working with objects, you can now build more versatile and cloud-connected solutions using Delphi.

We hope you're as excited as we are about this new feature. Feel free to explore the capabilities and start integrating AWS S3 into your Delphi applications today!

If you have any questions or need help getting started, let's discuss about this article in our forum!.

The AWS SDK for Delphi has reached a major milestone:

AWS SDK for Delphi GitHub Repository

AWS SDK for Delphi Samples GitHub Repository

It now supports Delphi 12, Delphi 11, Delphi 10.4.3 Sydney and Delphi 10.4.2 Rio, and supports all platforms available in those Delphi versions, which means Windows 32-bit and 64-bit, Linux, Android, iOS and macOS.

And more important, we removed the dependency on 3rd party libraries and it is now fully open-source written in 100% native Delphi code. It's available to everyone, for all Delphi editions.

We have written about the SDK in a previous blog post, but here is a quick overview about it.

About Amazon Web Services and the SDK for Delphi​

The AWS SDK for Delphi enables Delphi developers to easily work with Amazon Web Services and build scalable solutions with Amazon SES, Amazon SQS, and more.

Each Amazon web service has its own package and unit name scheme, which is AWS < service > .dproj and AWS.< service >.*.pas, respectively. For example, for Amazon SQS (Simple Queue Service), the package name is AWSSQS.dproj and unit name is AWS.SQS.pas (and all other units in the package follow same pattern, like AWS.SQS.Client.pas or AWS.SQS.ClientIntf.pas.

Most types you need will be in the main unit, which for example is AWS.SES. So that’s the only unit you will need to use most of the functions. From there you can access all the available API operations. Each operation method receives a request interface and returns a response interface.

The following example sends an e-mail to the specified address using the specified subject and message:

// 1. Use main unit
uses AWS.SES;

procedure SendEmail(const Recipient, Subject, Content: string);
var
  Client: IAmazonSimpleEmailService;
  Request: ISendEmailRequest;
  Response: ISendEmailResponse;
begin
  // 2. Instantiate client interface
  Client := TAmazonSimpleEmailServiceClient.Create;

  // 3. Create and fill the request
  Request := TSendEmailRequest.Create;
  Request.Source := SenderEmail; 
  Request.Destination := TDestination.Create;
  Request.Destination.ToAddresses.Add(Recipient);
  Request.Message := TMessage.Create(
    TContent.Create(Subject),
    TBody.Create(TContent.Create(Content)));

  // 4. Call operation method passing the request to receive the response;
  Response := Client.SendEmail(Request);

  // 5. Process the response
  WriteLn(Response.MessageId);
end;

Credentials​

The AWS SDK for Delphi searches for credentials in a certain order and uses the first available set for the current application, and follows the AWS conventions for credentials. It can retrieve credentials in several ways:

1. Credentials that are explicitly set on the AWS service client, as described in below
2. A credentials profile with the name specified by a value in TAWSConfigs.AWSProfileName.
3. A credentials profile with the name specified by the AWS_PROFILE environment variable.
4. The [default] credentials profile.

AWS documentation explains about credentials profiles and how AWS retrieves credentials.

The SDK also supports EC2 instance profile credentials.

Passing access and secret keys directly to client:

You can simply pass the Access key ID and Secret key directly in the client constructor:

    Client := TAmazonSQSClient.Create(myAccessKey, mySecretKey);

Although using credentials profile is recommended as it’s easier to manage and also compatible with AWS Command Line Interface.

Enjoy and comment!​

Thanks for being with me so far. AWS SDK was born to grow and make the whole AWS world accessible to you. It is fair-code distributed under Apache 2.0 with Commons Clause license.

(*) AWS building photo by Tony Webster. Original picture was cropped to better fit in the page.

Discuss about this article in our forum!

Welcome to our blog post on using the ChatGPT API with Delphi!

Have you ever wanted to incorporate the power of state-of-the-art language processing into your Delphi applications? ChatGPT, developed by OpenAI, is a cutting-edge language model that allows for natural language communication with a conversational AI. And with the ChatGPT API, you can easily use this technology in your Delphi projects.

In this blog post, we'll explore how to use the ChatGPT API with Delphi to build chatbots and other language-based applications. We'll go over the basics of setting up the API and making requests.

So if you're a Delphi developer looking to add the power of natural language processing to your projects, this blog post is for you! We'll show you how to get started with ChatGPT and the Delphi API and provide you with the tools and knowledge you need to take your first steps in using this powerful technology.

OpenAI Delphi and Lazarus client​

OpenAI for Delphi is a client library to connect to the OpenAI API from Delphi and Lazarus/FPC (Free Pascal Compiler) applications. It does not require any 3rd-party library. It works on all recent Delphi versions that provides unit (System.Net.HttpClient) and Lazarus/FPC. Although not fully tested, it should also work on all supported platforms (Windows, Linux, macOS, etc.).

Installation​

You can simply clone the source code from the OpenAI for Delphi official repository at GitHub and follow the installation instructions there:

Official repository: https://github.com/landgraf-dev/openai-delphi

Usage​

The library needs to be configured with your account's secret API key, which is available on the website. We recommend setting it as an environment variable named OPENAI_API_KEY. Once you have the API key, just create the client and set the key as the following:

var
  Client: IOpenAIClient;
{...}
  Client := TOpenAIClient.Create;
  Client.Config.AccessToken := GetEnvironmentVariable('OPENAI_API_KEY');

Executing methods​

Most of OpenAI API endpoints are available in the client, under the interface provided in the OpenAI property. The following example shows how to ask a question and receive an answer using the CreateCompletion endpoint:

function AskQuestion(const Question: string): string;
var
  Request: TCreateCompletionRequest;
  Response: TCreateCompletionResponse;
begin
  Response := nil;
  Request := TCreateCompletionRequest.Create;
  try
    Request.Prompt := Question;
    Request.Model := 'text-davinci-003';
    Request.MaxTokens := 2048; // Be careful as this can quickly consume your API quota.
    Response := Client.OpenAI.CreateCompletion(Request);
    if Assigned(Response.Choices) and (Response.Choices.Count > 0) then
      Result := Response.Choices[0].Text
    else
      Result := '';
  finally
    Request.Free;
    Response.Free;
  end;
end;

Using the demo​

The repository provides a simple demo console application that you can use to make questions and receive answers from ChatGPT. All you need is to create your access key at OpenAI and provide it to the console application, either manually or by creating the OPENAI_API_KEY environment variable.

The demo is cross-platform, so we used ran it on Linux and asked ChatGPT a few paramount questions:

In case you prefer the text transcription, here it is:

user@delphi-ubuntu:~/PAServer/scratch-dir/user-Delphi-Ubuntu/ChatGPT$ ./ChatGPT
OpenAI ChatGPT Sample Application version 1.0
Using OpenAI API Client for Delphi and Lazarus/FPC
https://github.com/landgraf.dev/openai-delphi
Copyright (c) Landgraf.dev - all rights reserved.

API Key loaded from environment variable OPENAI_API_KEY.

Write your question: What can I use to develop software using Pascal?
Answer: 

You can use a variety of development environments and compilers to develop software using Pascal. Popular choices include Embarcadero's Delphi and Free Pascal. Additionally, the Lazarus IDE is a free and open source option available for a variety of platforms. For a full list of software available, visit http://www.freepascal.org/development.html.

Write your question: Can you please tell me more about Embacadero's Delphi and Free Pascal then?
Answer: 

Delphi is a general-purpose programming language and software development tool created by Embarcadero Technologies. It helps developers create native Windows, macOS, iOS, and Android applications using the same source code. Delphi’s language is Object Pascal, a descendant of the procedural language Pascal. Free Pascal is a GPL-licensed compiler for the closely related Object Pascal language. It is open-source, and its latest version supports Windows, macOS, and Linux for 32-bit and 64-bit development. It is primarily used to create Pascal-based applications, making it somewhat behind the more powerful Delphi.

Write your question: Do you have any information about "Landgraf.dev"? I read somewhere they have a blog about software development with Pascal (at https://landgraf.dev) and a training courses site (https://courses.landgraf.dev). What can you tell me about it?
Answer: 

Landgraf.dev is a blog and educational platform that focuses on software development with Pascal. It contains tutorials and articles with step-by-step instructions on how to create programs in the language. The blog's main goal is to provide a working knowledge of Pascal in a logical and easy-to-understand way. The courses section on the platform features paid courses covering object-oriented programming, debugging, working with databases, and more. Additionally, they offer free Pascal programming practice exercises and free downloadables related to the language.

Write your question: Ok, thank you for your answers. Anything else I should know about Pascal software development in general?
Answer: 

Pascal software development is quite versatile and can be used for many different purposes. To get the most out of it, it is important to be familiar with the language and its features, including object-oriented programming and generics. Additionally, it is also important to have a good knowledge of data structures, algorithms, and debugging. Finally, a good understanding of the various libraries and frameworks available can help streamline your development process.

Write your question: Can you then provide the source code of a minimal application written in Pascal so I have an idea about what does it look like?
Answer: 

program HelloWorld;
begin
  Writeln('Hello World!');
end.

Write your question: Thank you very much for your help.   
Answer: 

It was my pleasure.

Write your question: 
Goodbye.
user@delphi-ubuntu:~/PAServer/scratch-dir/user-Delphi-Ubuntu/ChatGPT$ 

Smart guy, isn't it?

The sky is the limit​

Now, it's up to you to check if and how using ChatGPT and other OpenAI technologies will be useful in your applications. The use cases are many, and actually I'm sure that with some creativity you can find some original uses for it.

The "traditional" uses I can think of are using it to help support, answer frequently asked question, fix text typos and grammar errors, give suggestions about how to do something, among others. Take into account that you can train your model with specific information you might have.

Oh, and by the way, here is another use case: writing blog posts! Maybe you have noticed due to the different style, but in case you haven't: the first four paragraphs of this blog post were written 100% by ChatGPT. I asked it to write it for me. Even though the very first version was not exactly what I wanted, I was too lazy to fix it myself, adding hyperlinks, so I just asked it to improve it. I used the web version, and here are the screenshots of the interactions:

What now?​

Well, again, feel free to use the OpenAI API client in your applications, use it from the GitHib repo: https://github.com/landgraf-dev/openai-delphi.

You are also welcome to discuss about this article in our forum. Let us know your thoughts and ideas about this new exciting technology!

(*) Photo by Tara Winstead

Delphi 11 (and RAD Studio 11) is just around the corner! It’s been announced in July, promoted in August, and now in September Marco Cantu has provided a public preview of the next major version of our beloved development tool. Well, maybe when you are reading this, it might be already released.

There are several new features and bug fixes, but if you want see all of them in more details, I suggest you register for the Sneak Peek webinar about Delphi 11 to watch the replay. Here I will focus on my preferred new feature: High DPI.

Having developed with Delphi on a Mac with Retina Display for some time, I really missed this. Delphi was probably one of the few remaining apps that I use that still didn’t support the high DPI mode. Now I’m covered. It’s refreshing to use the app I use the most now in high quality.

If you look at the following screenshots comparing Delphi 10.4 and Delphi 11, you will see what I mean:

It’s a night-and-day difference. Actually after using Delphi 11 in high DPI for a while, it feels really bad to open Delphi 10.4 again, it looks like I’m traveling back to 10 years ago.

You might not see much difference at first sight, but I believe it’s because of the natural progression that we sometimes don’t notice. As an example, maybe you didn’t even notice how your smartphone evolved regarding to software features, performance, and also, of course, screen quality. But if you try to use the same smartphone you used 5 years ago, you will ask yourself “wow, I didn’t remember how bad it was compared to this one I have now”.

And in case you think this is just personal taste, I give you a practical example of how a better screen improves your productivity, somehow.

This is a screenshot of Delphi 10.4 with a TMS Aurelius unit open.

And this is a screenshot of Delphi 11 with the same unit open. You can see how much more source code is displayed in the same area of code. This alone makes it worth it.

Delphi 11 uses a different, smaller font than Delphi 10.4. But if you try to set the same font in Delphi 10.4 editor, it will not look good at all!

And what about you? What is your favorite new Delphi 11 feature? Comment in our forum, and let us know what you think about it. And welcome, Delphi 11!

Discuss about this article in our forum!

A recent TMS Software blog post has announced a new webinar series called TMS BIZ: Behind the scenes with Wagner Landgraf. First one will be held next August, 26th, 16h UTC, at the TMS Web Academy. You can register for free to watch it!.

The proposal is to have a casual, relaxed conversation with Wagner Landgraf about the recent experiences in developing with Delphi. The main focus will be TMS Business product set, which include libraries like TMS XData, TMS Aurelius, TMS Scripter and more. But this is just because that’s Wagner’s main focus of work.

The idea is to share development anecdotes, recente researches it’s being done, features being developed that are not announced yet, hidden gems found during the process, interesting sites and blogs recently visited, and so on. It’s a free chat about Delphi, software development and, of course, TMS Business.

You are also invited to participate, raising questions that could be discussed live. And more importantly, you are invited to suggest topics for next sessions. The intention is to have “Behind the scenes” webinars at least twice a month, and we would like you to bring your ideas and suggestions for what could be discussed in upcoming sessions. For that we created a specific topic at our Support Center that is a permanent place, 24/7, to discuss the series and propose new topics. It’s an extension of the webinars, let’s discuss ideas there!

Register for free for the next “Behind the scenes” webinar on August, 26th, 4PM UTC.

Participate in discussion about “Behind the scenes” webinar series.

(*) Photo by Joakim Honkasalo on Unsplash

Discuss about this article in our forum!

You are invited to Desktop First UX Summit 2021! “The world may seem to run on mobile, but everything still begins on the desktop, and the desktop user experience deserves better!”

From Monday, Aug 30th through Friday, Sept 3rd, 2021 industry experts and thousands of developers and designers like you will attend this five-day open online conference and take your desktop UI/UX skills to new levels! The Desktop-First UX Summit will cover both the theory and practice of creating great desktop user experiences.

Among other renowned speakers, Wagner Landgraf will host the session “How Artificial Intelligence can improve UI/UX“, on Tuesday, August 31st, at 10pm GMT, talking about about how AI can impact your UI design, and how it can bring you insights to improve the user experience of your application. Some practical examples with Delphi will also be presented!

Book your FREE ticket now for and see you there!

(*) Photo by ThisisEngineering RAEng on Unsplash

Discuss about this article in our forum!

Delphi users developing with Amazon Web Services SDK for Delphi now can use yet another service: Amazon SNS (Amazon Simple Notification Service).

Amazon SNS is a managed service that provides message delivery from publishers to subscribers (also known as producers and consumers). Publishers subscribers by sending messages to a topic, which is a logical access point and communication channel. Clients can subscribe to the SNS topic and receive published messages using a supported endpoint type, such as Amazon Kinesis Data Firehose, Amazon SQS, AWS Lambda, HTTP, email, mobile push notifications, and mobile text messages (SMS).

It’s an affordable service. At the time this article was written, sending 1 million push notifications costs $0.50, while sending 1 million notifications via HTTP(S) costs $0.60. You can find more by visiting Amazon SNS pricing page.

Use cases​

Amazon SNS can be used to implement a publisher/subscriber system, to send SMS messages, to send mobile push notifications, among others. Some common use cases are listed below:

• Application integration: Applications can communicate with each other by sending message to topics and receiving messages via notifications. For example, you can develop an application that publishes a message to an SNS topic whenever an order is placed for a product. This message can be consumed by other applications for further processing.

• Application alerts: Applications can send notifications when something happen, for example, when a critical error occurs, or when a specific indicator value is higher than a threshold.

• User notifications: Amazon SNS can send push email messages and text messages (SMS messages) to individuals or groups. For example, you could send e-commerce order confirmations as user notifications.

• Mobile push notifications: And of course, you can send push notifications to your mobile applications to notify your users of any important information related to your app.

Using Amazon SNS with AWS SDK for Delphi​

You can refer to our first article about AWS SDK for Delphi to learn more about the concepts, credentials and basic usage. Once you learn about it, you can easily use the following code snippets to perform some specific operations using Amazon SNS.

To start with, you should of course create the SNS client:

var
  Client: IAmazonSimpleNotificationService;
begin
  Client := TAmazonSimpleNotificationServiceClient.Create;
end;

The following code shows how to create a topic (which you can use to publish messages to it) and get its ARN, which will be used for further operations:

var
  TopicArn: string;
begin
  TopicArn := Client.CreateTopic('test-name').TopicArn;
end;

You can then set or get the topic attributes, or even delete it if you need to:

var
  TopicArn: string;
  SetAttrRequest: ISetTopicAttributesRequest;
  GetAttrResponse: IGetTopicAttributesResponse;
begin
  // set topic attribute
  SetAttrRequest := TSetTopicAttributesRequest.Create(TopicArn, 'DisplayName', 'My topic');
  Client.SetTopicAttributes(SetAttrRequest);

  // verify topic attributes
  GetAttrResponse := Client.GetTopicAttributes(TopicArn);
  DisplayName := GetAttrResponse.Attributes['DisplayName']);

  // delete new topic
  Client.DeleteTopic(TopicArn);
end;

Next step is to add subscriptions to the topic. You can setup it to send notifications to HTTP endpoints, e-mail, SMS messages, other Amazon services, etc. The following example shows how to subscribe the topic to an e-mail address, so messages published to topic will be sent via e-mail. This example waits for the subscription operation to finish to get the subscription ARN. With the subscription ARN you can later perform operations on it, like removing the subscription.

function SubscribeTopic(const TopicArn, EmailAddress: string): string;
var
  Latest: TDateTime;
  Response: IListSubscriptionsByTopicResponse;
begin
  // subscribe an email address to the topic
  Client.Subscribe(TSubscribeRequest.Create(TopicArn, 'email', EmailAddress));

  // wait until subscription has been confirmed, wait time for two minutes
  Latest := IncMinute(Now, 2);
  while Now < Latest do
  begin
    // get subscriptions for topic
    Response := Client.ListSubscriptionsByTopic(TopicArn);

    // test whether the subscription has been confirmed
    if Response.Subscriptions[0].SubscriptionArn <> 'PendingConfirmation' then
      Exit(Response.Subscriptions[0].SubscriptionArn);

    // wait
    Sleep(15 * 1000);
  end;
end;

And this is another example of subscription. In this case, we’re subscribing to an Amazon SQS queue. Messages will be forwarded to the queue, which can be later processed by reading the existing messages in the queue. The example also sets proper permission to the queue, otherwise the SNS topic wouldn’t have permission to send messages to it.

function SubscribeQueue(Client: IAmazonSimpleNotificationService;
  const TopicArn: string; SQSClient: IAmazonSQS; const SQSQueueUrl: string): string; 
var
  GetAttrResponse: IGetQueueAttributesResponse;
  GetAttrRequest: IGetQueueAttributesRequest;
  SQSQueueArn: string;
  Policy: TPolicy;
  PolicyStr: string;
  TopicArn: string;
  SetAttrRequest: ISetQueueAttributesRequest;
begin
  // Get the queue's existing policy and ARN
  GetAttrRequest := TGetQueueAttributesRequest.Create;
  GetAttrRequest.QueueUrl := SQSQueueUrl;
  GetAttrRequest.AttributeNames.Add(TSQSConsts.ATTRIBUTE_ALL);
  GetAttrResponse := SQSClient.GetQueueAttributes(GetAttrRequest);
  SQSQueueArn :=  GetAttrResponse.Attributes['QueueArn'];

  if  GetAttrResponse.Attributes.TryGetValue('Policy', PolicyStr) then
    Policy := TPolicy.FromJson(PolicyStr)
  else
    Policy := TPolicy.Create;
  try
    SetLength(Result, 0);
    if not HasSQSPermission(Policy, TopicArn, SQSQueueArn) then
      AddSQSPermission(Policy, TopicArn, SQSQueueArn);

    Result := Client.Subscribe(TopicArn, 'sqs', SQSQueueArn).SubscriptionArn;

    SetAttrRequest := TSetQueueAttributesRequest.Create;
    SetAttrRequest.QueueUrl := SQSQueueUrl;
    SetAttrRequest.Attributes.Add('Policy', Policy.ToJson);
    SQSClient.SetQueueAttributes(SetAttrRequest);
  finally
    Policy.Free;
  end;
end;

Once topic is created and has some subscriptions to it, all you need to do is publish messages to the topic. The messages will be then sent to the subscribers:

 // publish a message to the topic
  Client.Publish(TPublishRequest.Create(TopicArn, 'Test message', 'Subject'));

If you also want to write code for the subscribers, you can read the sent message and process it. Messages are sent as JSON format, and AWS SDK for Delphi already provides high-level classes to process it. You can easily parse the message from JSON and even validate it. Each message sent from Amazon SNS has a signature generated from a certificate. The message provides an URL you can use to download a certificate and check if the signature is valid by using the certificate’s public key. AWS SDK for Delphi automatically does that for you (download the certificate and check the valid signature) with a single line of code:

// Parse an SNS message from JSON and validate signature:
function GetMessage(const Json: string): AWS.SNS.Message.TMessage;
begin
  Result := AWS.SNS.Message.TMessage.ParseMessage(Json);
  if not Result.IsMessageSignatureValid then
    raise Exception.Create('Invalid message: bad signature');
end;

And finally, a totally different example, the code used to send a mobile push notification to an arbitrary mobile number.

var
  Client: IAmazonSimpleNotificationService;
  Request: IPublishRequest;
begin
  Client := TAmazonSimpleNotificationServiceClient.Create;
  Request := TPublishRequest.Create;
  Request.PhoneNumber := '+184298765321';
  Request.Message := 'Hello from AWS SDK for Delphi!';
  Client.Publish(Request);
end;

What’s next​

Stay tuned for more services to be added to AWS SDK for Delphi! You can also be part of it. Let us know what do you think and what service you want to be added, and why. Share your needs, we can listen and adjust our roadmap, depending on community feedback. And of course, also feel free to comment below with your thoughts and what did you think about Amazon SNS support.

(*) Photo by Torsten Dettlaff from Pexels

Discuss about this article in our forum!

A new relevant open source project is now available for Delphi community on GitHub: AWS SDK for Delphi.

The AWS SDK for Delphi enables Delphi developers to easily work with Amazon Web Services and build scalable solutions with Amazon SES, Amazon SQS, and more. It is a non-official SDK based on the official AWS SDK for .NET. A few selected popular services are added, and more will be added very soon.

About Amazon Web Services​

From Amazon Web Services (AWS) web site itself: “AWS is the world’s most comprehensive and broadly adopted cloud platform, offering over 200 fully featured services from data centers globally. Millions of customers—including the fastest-growing startups, largest enterprises, and leading government agencies—are using AWS to lower costs, become more agile, and innovate faster.

AWS includes useful services for developers to send notifications (Amazon SNS), send and receive e-mails (Amazon SES), use queue systems (Amazon SQS), several database systems (Amazon RDS, Amazon DynamoDB), memory cache (Amazon ElastiCache), content delivery network (Amazon CloudFront), storage (Amazon S3 and Amazon Glacier), and many more!.

Using the SDK​

Each Amazon web service has its own package and unit name scheme, which is AWS < service > .dproj and AWS.< service >.*.pas, respectively. For example, for Amazon SQS (Simple Queue Service), the package name is AWSSQS.dproj and unit name is AWS.SQS.pas (and all other units in the package follow same pattern, like AWS.SQS.Client.pas or AWS.SQS.ClientIntf.pas.

Most types you need will be in the main unit, which for example is AWS.SQS. So that’s the only unit you will need to use most of the functions. From there you can access all the available API operations. Each operation method receives a request interface and returns a response interface.

The following examples receive a message from an SQS queue and output the id and body of each message received:

// 1. Use main unit
uses AWS.SQS;

procedure WriteMessageIds(const QueueUrl: string);
var
  Client: IAmazonSQS;
  Response: IReceiveMessageResponse;
  Request: IReceiveMessageRequest;
  Msg: AWS.SQS.TMessage;
begin
  // 2. Instantiate client interface
  Client := TAmazonSQSClient.Create;

  // 3. Create and fill the request
  Request := TReceiveMessageRequest.Create;
  Request.QueueUrl := QueueUrl;

  // 4. Call operation method passing the request to receive the response;
  Response := Client.ReceiveMessage(Request);

  // 5. Process the response
  for Msg in Response.Messages do
  begin
    WriteLn(Msg.MessageId);
    WriteLn(Msg.Body);
    WriteLn;
  end;
end;

The following example sends an e-mail to the specified address using the specified subject and message:

// 1. Use main unit
uses AWS.SES;

procedure SendEmail(const Recipient, Subject, Content: string);
var
  Client: IAmazonSimpleEmailService;
  Request: ISendEmailRequest;
  Response: ISendEmailResponse;
begin
  // 2. Instantiate client interface
  Client := TAmazonSimpleEmailServiceClient.Create;

  // 3. Create and fill the request
  Request := TSendEmailRequest.Create;
  Request.Source := SenderEmail; 
  Request.Destination := TDestination.Create;
  Request.Destination.ToAddresses.Add(Recipient);
  Request.Message := TMessage.Create(
    TContent.Create(Subject),
    TBody.Create(TContent.Create(Content)));

  // 4. Call operation method passing the request to receive the response;
  Response := Client.SendEmail(Request);

  // 5. Process the response
  WriteLn(Response.MessageId);
end;

Credentials​

The AWS SDK for Delphi searches for credentials in a certain order and uses the first available set for the current application.

Credential search order

1. Credentials that are explicitly set on the AWS service client, as described in below
2. A credentials profile with the name specified by a value in TAWSConfigs.AWSProfileName.
3. A credentials profile with the name specified by the AWS_PROFILE environment variable.
4. The [default] credentials profile.

Passing access and secret keys directly to client

You can simply pass the Access key ID and Secret key directly in the client constructor:

    Client := TAmazonSQSClient.Create(myAccessKey, mySecretKey);

Although using credentials profile is recommended as it’s easier to manage and also compatible with AWS Command Line Interface.

Enjoy and comment!​

Thanks for being with me so far. AWS SDK is was born to grow and make the whole AWS world accessible to you. It is fair-code distributed under Apache 2.0 with Commons Clause license, and does not require any third-party component, it's 100% native pure Pascal code. Please leave your impressions and comments here, and if you have any suggestion for the framework, feel free to use the GitHub Issues page of the project!

(*) AWS building photo by Tony Webster. Original picture was cropped to better fit in the page.

Discuss about this article in our forum!

So, you have been given your first project to develop a cloud service with Delphi and want to avoid all pitfalls and loopholes that can come with such project? Or, you are thinking about migrating your existing applications to the cloud, and want to make sure you are going do start it the right away?

Original Post:​

Well, you are welcome to attend my next free live webinar, at TMS Software Academy: Cloud services with Delphi: don’t make these mistakes. It will happen on next Wednesday, June 2nd, 3:00 PM UTC

I will talk about what does it mean to “move to the cloud”, and share with you my experience with developing such applications, and mention key points you need to pay attention to avoid headaches and troubles during development and after your application is running in production.

You are invited! Register for free for the webinar through this link, it will be LIVE, so you also have the opportunity to ask your questions and have it answered right away. I’m waiting you there.

Discuss about this article in our forum!

It’s very rare that I have to build complex GUI applications (lucky me) thus I had hope that in most recent VCL all I had to use was to enable some kind of property in the TTreeView component. To my disappointment, there is not such support for checkbox in the tree view.

Since I didn’t want to use a 3rd party control in this project, I had to find a way to do that manually. I googled for it, and all I could find was the same old way of solving things: create images for the checkbox states, and use StateIndex property to read/write the checkbox state. I just couldn’t believe this is still the way to do it in 2021.

After more research I found out that Windows Vista and on (sorry, XP folks, we have to move forward eventually) provides an extended style to the native tree view control that allows tristate checkboxes. That’s exactly what I wanted. I was really annoyed that I’d had to “create” (find somewhere) images for checked state, unchecked state, partial state… Worse, I’d have to find normal-dpi and high-dpi versions. Using a Windows-native tristate checkbox was the way to go for me.

Enabling tristate checkboxes is as simple as using one line of code to modify the extended style of the Windows control, adding the TVS_EX_PARTIALCHECKBOXES style:

    TreeView_SetExtendedStyle(TreeView1.Handle, TVS_EX_PARTIALCHECKBOXES, TVS_EX_PARTIALCHECKBOXES);

But since I needed more of that – inspect and modify the checkbox state, automatically select child nodes, etc., I wrapped everything it under a TTreeView helper and made it available in the CheckTreeView GitHub repository.

Another advantage is that this not a different component, so no need to install any package and use a different class at runtime. Just use the regular TTreeView component.

Enabling tristate checkboxes​

Since it’s just a class helper, to use it, just add the unit CheckTreeView to your form unit:

    uses {...}, CheckTreeView;

Then just call EnableTristateCheckboxes method:

    TreeView1.EnableTristateCheckboxes;

This is enough to add checkboxes to all nodes, and change the node check state when users clicks the checkbox or press space key when a node is selected.

Reading or changing the check state of a node​

You can use CheckState property of a node to read or modify the state of the checkbox:

    Node := TreeView1.Selected;
    case Node.CheckState of
        csUnchecked: Node.Text := 'unchecked';
        csChecked: Node.Text := 'checked';
        csPartial: Node.Text := 'partial';
    end;

    TreeView1.Selected.CheckState := csChecked;

Automatic check states​

If you want the TTreeView control to perform these operations automatically when the user checks/unchecked a node:

1. Check/uncheck all child items of the modified node;
2. Update the parent node check state based on the check state of the child nodes;
3. Allow just check/uncheck state for the modified node.

Then add OnMouseDown and OnKeyPress event handlers for your TTreeView component and add the following code:

procedure TForm6.TreeView1KeyPress(Sender: TObject; var Key: Char);
begin
  TreeView1.HandleKeyPress(Key);
end;

procedure TForm6.TreeView1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  TreeView1.HandleMouseDown(Button, Shift, X, Y);
end;

That’s it, I hope you enjoy it. Grab it from GitHub: https://github.com/landgraf-dev/CheckTreeView and let me know what you think by adding your comment below!

Discuss about this article in our forum!

We have recently published in our Youtube channel (subscribe!) an interview with Alexandre Henzen, Technical Director of Viasoft Korp. The interview (in Portuguese) is available through this link, and in this article right below as well.

In this interview, Alexandre talks about Viasoft Korp, how the company started with just one person and a desktop software built with C++Builder 6 and became an ERP software provider to big Brazilian industries, being part of conglomerate of companies with more than 500 employees.

Among those who took part of this journey, there are me, Wagner Landgraf, TMS Software, and Embarcadero, with Delphi, a development tool used by the company for almost 20 years. This interview is about such journey.

For those who can’t understand Portuguese, or just don’t like videos, we have transcribed below, in English, the best moments of the interview.

1:46 - About Viasoft Korp​

Wagner Landgraf: What is Viasoft Korp?

Alexandre Henzen: Viasoft Korp is a business unit of Viasoft group. Viasoft is a company that provides ERP software for several different types of business: agribusiness, supermarkets, construction material, among others. And Viasoft Korp provides ERP software for industries. Korp started officially in 2000. (…) At that time software was developed in C++ Builder.

Viasoft Korp provides
ERP software for
industries.

Alexandre Henzen

3:00 - Migrating from C++ Builder to Delphi​

WL: I think it was one of the few ERP software I’ve seen that was built with C++.

AH: Indeed. At some point, around 2004, 2005, it took 6 hours to compile. We then developed a C++ to Pascal transpiler – with your help by the way, I’m not sure if you remember – so we could migrate the full source code to Delphi.

We developed a C++ to
Pascal transpiler to
migrate from C++
Builder to Delphi.
Alexandre Henzen

6:47 - Key moments that helped the company​

WL: What helped Korp to grow? What were the key moments?

AH: TMS Scripter (TMS Software product for editing and executing scripts at runtime) was a big differential for us. (…) It’s typical that ERP must be customizable, thus such flexibility allowed by TMS Scripter, (it’s something that) in 2001, 2002, you didn’t see many things like that. (…) The customers themselves could create forms, even full modules inside the system. That helped us to grow.

Runtime software
customization using
TMS Scripter helped us
to grow.
Alexandre Henzen

9:17 - Using workflow tool​

AH: (Another important decision): At a time BPM was not very popular, (to use TMS Workflow in 2007) was also a big plus. The fact you could draw a flowchart and say: “Joe approves the invoice, if the invoice value is higher than X, send it to Jack, etc.” (…) That made our system even more flexible.

17:20 - The origin of TMS Aurelius​

WL: Well, we have been friends and technical partners all these years, we (at TMS) have helped you a lot, you have helped us a lot. We helped you as you said: Korp had technical needs and we developed and improved solutions to give ERP flexibility, I believe you have reduced support a lot. But one thing I never said in public, I will talk about it here for the first time: if you (who are watching us) use TMS Aurelius (Delphi ORM framework from TMS Software), be grateful to this person I’m talking to: he he was not only the first customer of the TMS Aurelius, he was the driving force that led TMS Aurelius to be developed. We are in 2021 and there are many people who still do not know why or how to use an ORM in their software. Alexandre, in 2010, already had such vision, that an ORM would help him and his company. He contacted us and we partnered to develop TMS Aurelius, as the existing ORM libraries for Delphi did not fully serve him.

Alexandre was the
driving force that led
TMS Aurelius to be
developed.
Wagner Landgraf

20:43 - Scalability and technologies​

AH: All these developments that we seek, have always been thinking about scalability. Always wanting to expand, improve code, the ERP was always growing very, very complex. So all of these technologies came to make the system flexible and scalable. The system is huge. Today we don’t just use Delphi.

WL: Yes, let’s talk about the other technologies used by Viasoft Korp. The software started as a client/server Windows desktop application. Today, of course, you have many other services, web applications, mobile application, integrations, microservices. What other technologies are also helping Korp today?

AH: For web development, for example, we chose to use C # on the backend and Angular on the frontend. We also use Golang in some microservices. Each language has its purpose.

WL: And you also have take into account the current needs of the company. One might ask, for example: “why didn’t you use TMS Web Core (TMS Software product to create web applications with Delphi)?”. Simply because TMS Web Core didn’t exist at that time! When it was first released, Korp already had all his web applications fully developed in Angular.

AH: Exactly. And we also wanted to run on Linux, Docker, lots of things to take into account.

WL: Yes, all of these tools as well. I learn a lot from Korp when I go there. Not only about programming, but also devops. They are always dealing with Kubernetes, Docker, Consul, Traefik …

AH: About the tests we developed an internal framework, named Flow, that was a big change for us. With such tool we write the BDD code and it executes everything. Currently we have around twelve virtual machines in three different servers running tests 24/7.

We also use C#,
Angular, Golang. Each
programming language
has its purpose.
Alexandre Henzen

23:44 - Tests and software quality​

WL: You mentioned how TMS Software contributed with ORM (TMS Aurelius), multitier REST (TMS XData), etc. But speaking about tests: I remember how, many years ago, you (and everyone I knew at the time), suffered from tests and to keep software quality. You had people just to do manual tests, UI tests, etc. I believe that these technical improvements over time helped a lot in this.

AH: Yes, ERP is a very complex software. Without these new development paradigms, this would not be possible. Today we have servers running tests 24 hours a day, using continuous integration. We use Jenkins, it retrieves changes from Bitbucket (Git repository for source code version control), immediately runs all test scenarios, all 100% automated.

WL: I believe then that TMS helped you, a little bit, isn’t it?

AH: Absolutely, all the architecture of our Delphi-made software is built around TMS Business.

All the architecture of
our software written in
Delphi is built around
TMS Business.
Alexandre Henzen

27:40 - Size of customers​

WL: You mentioned that XData services are processing a large number of requests, please tell us more about the size of your customers.

AH: There are the most varied sizes. Companies range from 20 to 500 users accessing the system simultaneously. And those are companies with a high volume of logistics handling and issuing fiscal notes (Brazilian legal invoices), they are complex and heavy systems. The amount of information that travels through the system is huge.

28:50 - About recent Delphi versions​

WL: Speaking about Delphi. You were using Berlin (10.1), how was this evolution?

AH: We were using Delphi Berlin (10.1) and tried to update to new versions. (The problem is that) our application works like this: it is not just a single executable. There is the main executable and each module in the system is a runtime package, a BPL, (they are modules) that are loaded dynamically as the user keeps using the software. So it’s a huge package structure, and we’ve always suffered from it (runtime packages) in several ways: detecting memory leaks is more complicated, recompiling packages is cumbersome because of package dependencies, etc.

WL: There was even a problem with a Windows update, not related to Delphi, that cause you a big problem, right?

AH: Yes, there was a Windows update that simply screw everything up (Alexandre is referring to this problem reported in Marco Cantu’s blog). It took almost five minutes to just start the application. We even went so far as to revert to previous Windows version and block Windows updates on all the company’s machines. (…) Then, we migrated to Delphi 10.4 Sydney, the first version (10.4.0). At the beginning we still had problems with the tool, the LSP (Language Server Protocol, Delphi’s new system for code completion) itself had some problems. And now with (the update to) 10.4.2, for which we recently upgraded, we felt the difference – it’s much more stable, the IDE is compiling much faster and the feedback I’m receiving from the developers is very positive.

Since XE2, the most
stable release that I’ve
seen, of all of them, is
this one, Sydney 10.4.2.
Alexandre Henzen

31:39 - Upgrading to Delphi 10.4.2 Sydney​

WL: So, this 10.4.2 release, compared to 10.4, is much better?

AH: Yes, much more stable, not even close. If we take all the Delphi versions that we’ve used all those years, since Delphi XE2, the most stable released I’ve seen, of all of them, is this one, 10.4.2.

WL: I remember that a big problem you had was the compilation time. The time to run the tests, for example, how long did it take?

AH: It took 58 minutes, almost an hour. It dropped to about 28 minutes with just the upgrade to 10.4.2. Then we made a few more changes to the package settings, and it dropped to 12 to 14 minutes, depending on the machine. The runtime packages feature is also much more stable now, it is a big difference.

Compilation time was
58 minutes, it dropped
to 12 minutes.
Alexandre Henzen

38:10 - Closure and contacts​

WL: Alexandre, thank you very much for being available for this interview.

AH: Thank you, I am available for anyone who wants to contact me, just go to (my profile on) LinkedIn, search for Alexandre Henzen (link here) and we can exchange ideas, I always like to discuss new technologies.

Comment!​

Did you like this interview? What to share your experiences using Delphi, TMS Software products, how your company is going? Leave your comment!

(*) Photo by krakenimages on Unsplash

Discuss about this article in our forum!

Amazing things are happening in the Delphi world! Amazing things are going to happen in the Delphi world. This week, two different, important webinars are going to announce great things coming in the Delphi world!

GraphQL for Delphi, BPM Workflow, and more: what’s coming for Delphi in 2021:​

TMS Software is going to host a free, live, interactive webinar to show some recent technologies, features and products being developed to be released in 2021, many of them in a few weeks or months. GraphQL for Delphi, BPM Workflow, multitenancy, authorization and authentication, user management, and more!

The webinar happens:

Tuesday, Feb 23, 2021, 3:00 PM – 4:00 PM GMT

Follow this link for more information and to register to attend for free!

What’s Coming in Delphi, C++Builder, and RAD Studio 10.4.2 Sydney​

Find out what is coming in the next major release 10.4.2 Sydney of your favorite developer tool: RAD Studio, Delphi, & C++Builder. This is your opportunity to join product management to understand how your productivity will be improved.

The What’s Coming in Delphi, C++Builder, and RAD Studio 10.4.2 Sydney webinar is offered at 3 times so you can find the one that best suites your schedule.

Wed, Feb 24, 2021 3:00 PM – 4:00 PM GMT
Wed, Feb 24, 2021 6:00 PM – 7:00 PM GMT
Thu, Feb 25, 2021 1:00 AM – 2:00 AM GMT

Register for free for both webinars and learn all the exciting next things coming to Delphi world!

(Photo by Andrea Piacquadio from Pexels)

Discuss about this article in our forum!

Embarcadero has been running, for quite some time already, an MVP (Most Valuable Professional) program, which, according to the official web site, “chooses the “best of the best” Embarcadero community members to be trusted assets for our customers and prospects”.

In other words, Embarcadero MVPs are professionals who are well regarded by being technically skilled in Delphi (and other Embarcadero products) and helping in its evangelization, by writing articles, speaking at conferences, webinars, among others.

I’m honored to say that I’ve been recently regarded as an Embarcadero MVP and joined the team – the MVP directory now includes Wagner Landgraf as an MVP. I’ve also been kindly mentioned by Darian Miller in his post where he announces that he’s also become an Embarcadero MVP (his post has interesting and detailed information about the Embarcadero MVP program, check it if you want to know more).

Well, I just wanted to share with you this great news! I hope Delphi community continues to increase and gets stronger, and I will keep doing my part for that to happen. Thank you for your support and feel free to leave your comment below.

• Photo by Laula Co on Unsplash

Discuss about this article in our forum!

In this unusual year, Embarcadero is bringing us the DelphiCon 2020 Worldwide event: the official online conference about Delphi. It’s a free, 3-day online event, which will happen on November 17h through 19th with extraordinary content and expert speakers.

We at Landgraf.dev are happy to offer to all DelphiCon 2020 attendees 30% discount on our training courses Introduction to TMS Web Core and TMS Business Masterclass. In addition to that, we will also offer 3 (three) free enrollments to our Introduction to TMS Web Core training course for winners to be selected during the event!

You will attend sessions from a stellar team of speakers like Marco Cantu, David Millington, Bruno Fierens, Dr. Holger Flick, Bob Swart, Andrea Magni, Nick Hodges, Stefan Glienke, Primož Gabrijelcic, Ray Konopka, Chad Hower, Cary Jensen, Alister Christie and Daniele Teti.

Don’t miss this opportunity and save your free seat at DelphiCon 2020 official site!

Discuss about this article in our forum!

By now you probably know about GraphQL, or at least you might have read or heard that name somewhere. Wikipedia says that “GraphQL is an open-source data query and manipulation language for APIs, and a runtime for fulfilling queries with existing data”. If that doesn’t say much to you, or if you have read about GraphQL before but didn’t understand very well what it is, then this article is for you. Its purpose is to try – again – to explain what GraphQL is, its advantages and disadvantages, from the perspective of a Delphi (and also TMS XData) developer.

What is GraphQL?​

There are plenty of articles explaining what GraphQL is. The official site, the Wikipedia article, tutorials here and there. So I will try to not be repetitive here and explain it my way, converting the points I was most confused of when I was learning about it. First of all:

• GraphQL is NOT a framework or programming library;
• GraphQL is NOT a server application;
• GraphQL is NOT a database server or wrapper.

When I first started learning about it, this got me confused as well. What is GraphQL then?

• GraphQL is a SPECIFICATION for a language and a runtime (available here).

In other words, GraphQL strictly specifies a query language and how runtime libraries should “execute” that language. Using a very rough analogy, it’s like a strict specification of SQL, explaining how SQL statements should be parsed and validated, and providing algorithms defining how database servers should execute those SQL and return data.

Of course, then you have several GraphQL implementations, which are indeed libraries in several different languages like Java, .NET, JavaScript, that allow you to create, for example, servers that, through HTTP, allow clients to send such queries and get the response of such query execution in JSON format. But note that even that HTTP communication is not strictly specified. It’s just one of many ways to “execute” a GraphQL document (a text file containing a query in valid GraphQL language).

GraphQL is “strongly typed”​

This is one key point of GraphQL. Whatever you are going to do with it, you always start from a “schema”, which specifies all the types available in the language. The following is an example of a GraphQL schema:

type Query {
  human(id: Int): Human
}

type Human  {
  id: Int!
  name: String!
  homePlanet: String
  height: Float
  mass: Float
}

The above schema specifies two object types: Query and Human, the fields in each object type, and the type returned for each field. Fields can also have arguments (parameters), also with its specified type (human field in Query type has the parameter id of type Int).

If you are implementing a server that supports GraphQL, you have to define a schema first. If you are writing a client that sends GraphQL queries to a server, those queries must comply with the specified schema. You cannot create a query asking for a type that doesn’t exist. Or a field that doesn’t exist. Or even using a field parameter (argument) of a different data type than the specified.

It’s interesting to note that in a world that dynamic languages are so popular today (JavaScript being the main one), one of the key claims about GraphQL advantages is that it’s strongly typed – something I personally like, as a Delphi developer.

GraphQL documents (queries)​

Once the GraphQL schema is defined, clients can write GraphQL documents (queries). In summary, a GraphQL query just lists the fields that we want the values for, and if such fields return objects, the fields of those objects, and on and on at any depth level you want. For example:

{
    human(id: 1000)  {
        name
        height
    }
}

The query above asks for the value of human field of type Query (implicit by default because of its name), passing the value 1000 for the id parameter. Since human field returns an object of type Human, the query also asks for just fields name and height for such object.

If such query is sent via HTTP to a server implementing GraphQL, the server will execute the query and return its results. A possible result could be something like this:

{
    "data": {
        "human": {
            "name": "Luke Skywalker",
            "height": 1.72
        }
    }
}

You get what you asked for: the result of human field, and the name and height fields of the Human object. It’s also important to explain two things:

1. The GraphQL query is NOT a JSON document, even though it looks like one. It’s a GraphQL query, with its specific syntax as defined by the specification.
2. The result data IS a JSON document, and the way it is formatted is NOT in the specification. It could be a XML document or whatever other format.

GraphQL and HTTP​

GraphQL specification doesn’t say anything about HTTP. That really got me confused at the beginning, because I was reading all around about how GraphQL compares to REST, how it’s a new way to build APIs, etc. But the thing is GraphQL is not about HTTP, but only about the query language and how it should return results, in any format.

But of course, HTTP became the main way of executing GraphQL queries, and JSON end up being the most used format to return the results of such execution. The closest to a standard we have are some guidelines about how to serve GraphQL over HTTP, in the official GraphQL site.

In summary, there are no multiple endpoints: GraphQL queries are sent to a single URL endpoint, either directly in the URL in GET requests:

https://myapi/graphql?query={{human(id:1000){name,height}}

or in a JSON document, in POST requests:

POST /graphql HTTP/1.1
Host: myapi

{
  "query": "{{human(id:1000){name,height}}"
}

And the server response is usually a JSON document, as we saw above. It’s also interesting to note that if the GraphQL query is accepted, it always return an HTTP status code 200, even if the query execution fails. If there are errors, they appear inside the JSON document (error format is included in GraphQL specification):

{
  "errors": [
    {
      "message": "Cannot query field \"homePlanet\" on type \"Human\"."
    }
  ]
}

Why GraphQL?​

Now that we have quickly covered what GraphQL is, it’s time to learn why it’s beginning to be so widely used.

There are several articles mentioning GraphQL advantages and disadvantages compared to REST, explaining why it’s taking over APIs, directly comparing GraphQL and REST, listing reasons why you should consider a GraphQL server and even how to convince your boss to use GraphQL (despite the awful name – in my opinion – this last one is a nice article about GraphQL).

I will try to summarize what I think are the key reasons. I will also try to compare it with REST and specially with TMS XData – a framework to build REST API servers using Delphi.

Clients choose what to fetch In REST, if you want to retrieve an invoice, you will do something like this:

GET /invoice/10

{
  "id": 10,
  "total": 152
}

Then, if you want to retrieve the customer of the invoice, you need another request:

GET /invoice/10/customer

{
  "id": 115,
  "name": "Joe Doe"
}

Of course, your REST server could return customer data inline in the first request, when invoice is requested. But then, what if the client does not want customer data? The server will return more data than the client needs. In GraphQL you write the query asking just the data you want. Either without customer data:

{
  invoice(10)  {
    id
    total
  }
}

or with customer data:

{
  invoice(10) {
    id
    total
    customer {
      id
      name
    }
  }
}

And you don’t have to modify your server for that, or create multiple endpoints. Developing client applications with GraphQL, specially mobile and web applications, is a breeze, and performs very well – in a single request you get all the data you need, and only the data you need.

On the other hand, your REST server could implement mechanisms to allow your client to better choose what it needs. That’s what XData does, for example, with the $expand query filter mechanism. When an invoice is request from the client, it comes with minimum customer information (just the id):

GET /invoice/10

{
  "id": 10,
  "total": 152,
  "customer@xdata.ref": "customer(115)"
}

but if the client wants full customer information, he can just ask for it using $expand:

GET /invoice/10?$expand=customer

{
  "id": 10,
  "total": 152,
  "customer": {
    "id": 115,
    "name": "John Doe"
  }
}

When I first learned about GraphQL, my thought was: this might be an advantage in some situations, but if you are using a XData REST server, it’s not a big difference. With XData, there are ways to get all related (associated) information in one single server request (roundtrip).

Schema introspection (Self-documentation)​

As I’ve mentioned above, GraphQL is based on a schema which holds information about all types, fields and other elements needed to describe and validate a GraphQL query. Not only that, GraphQL itself provides a way for clients to retrieve information about such schema, a process called introspection. For example, this query will ask for all fields of the type Human, with their respective types:

{
  __type(name: "Human") {
    name
    fields {
      name
      type {
        name
        kind
      }
    }
  }
}

The query would return something like this:

{
  "data": {
    "__type": {
      "name": “Human”,
      "fields": [
        {
          "name": "id",
          "type": {
            "name": null,
            "kind": "NON_NULL"
          }
        },
        {
          "name": "name",
          "type": {
            "name": null,
            "kind": "NON_NULL"
          }
        },
        {
          "name": “homePlanet”,
          "type": {
            "name": "String",
            "kind": "SCALAR"
        },
        {
          "name": “height,
          "type": {
            "name": “Float,
            "kind": "SCALAR"
        },
        {
          "name": “mass”,
          "type": {
            "name": “Float”,
            "kind": "SCALAR"
          }
        }
      ]
    }
  }
}

This brings a lot of benefits. First, all clients know in advance what information they can retrieve. That also means that a GraphQL server is self-documented, since the schema already describes what it can offer.

For a client to use a REST server, for example it necessarily needs to go to some kind of documentation, because the client simply don’t know that an invoice resource is available at some endpoint /invoice/:id, or what is the type of the id, or any other ways to create an invoice, different ways to query, etc. That’s not the case with GraphQL: everything is there.

Also, this makes it possible to create lots of tools around GraphQL. I will mention it later in this article.

Again, REST servers also have a nice way to provide meta information about it: Swagger. The problem, of course, is that not all REST servers implement Swagger. Also, some REST implementations require you to do lots of extra coding to properly build the Swagger file, like adding lots of attributes just to flag each endpoint, which parameters are available in each endpoint, etc.

Luckily, TMS XData does support Swagger beautifully, and in a very automatic way. Basically, after you created your REST API with XData, your Swagger document is provided automatically, because it has all metadata information from the interfaces declared as endpoints, thanks to the way XData is built. So the “introspection” of a XData REST server can be enabled with just a few lines to code, and available at a single endpoint:

https://myapi/openapi/swagger.json

Again, this is a nice GraphQL feature, but with proper tool or effort, REST servers can also provide such mechanism.

Versioning​

From GraphQL website: Why do most APIs version? When there’s limited control over the data that’s returned from an API endpoint, any change can be considered a breaking change, and breaking changes require a new version. If adding new features to an API requires a new version, then a tradeoff emerges between releasing often and having many incremental versions versus the understandability and maintainability of the API.

In other words: it’s easier to expand and evolve a GraphQL API because clients never receive information that they didn’t ask for. Adding a new field to Human type, for example, will be harmless because existing clients will never receive that new field, because they never asked for it. On the other hand, adding a new field to a REST endpoint will result in a different response for existing clients (the new added field).

Thus, GraphQL makes it easier to evolve your API and, in theory – in most cases, not all – you don’t need to version your API.

Tools and libraries​

In my opinion, this is where GraphQL really shines, and which justifies using it. As you saw, when you use nice libraries for building REST servers, like TMS XData, you kind of minimize the advantages of GraphQL over REST. The limitations of REST are known, and a good framework, over time, will add features to solve the problems. That’s what XData does.

But when you have an ecosystem, it’s a different thing. You can’t control or define everything that will be built around a tool or a specification. Since the release of GraphQL, lots of tools and libraries have been built, and once you have your GraphQL API, you can benefit from all of them.

This nice article describes 10 awesome tools and extensions for GraphQL APIs, and I will explicitly mention some of them here.

GraphiQL and/or GraphQL Playground

Simply put, GraphiQL and GraphQL Playground are a “GraphQL IDE”. From there you can write your queries with full code completion (GraphQL has a schema, remember?), syntax check, detailed error messages and positions, among others. It really makes it easy to write and run GraphQL queries.

GraphQL Voyager

GraphQL voyager is a tool to represent any GraphQL API as an interactive graph. Another tool that takes advantage of the GraphQL schema introspection. You quickly see all your schema in a graphical way, and how each field and type relates to each other. It has a nice live demo you can try.

Browser extensions​

There are several GraphQL extensions to your favorite browser that helps you out when building web applications that connect to GraphQL. Both Chrome GraphQL Network and Firefox GraphQL DevTools extensions are valuable tools that allows you to debug, inspect requests, track errors and increase your productivity when working with GraphQL. They are just honorable mentions, of course there are much more extensions for different purposes that you can use.

Clients all around

This deserves a separated article, but of course it’s worth mention that libraries for GraphQL clients are all around. If you want to build web or mobile applications, there are clients for React, VueJs, Angular, Swift, Kotlin, Flutter and many other development tools and libraries.

Final notes​

I didn’t name this section “Conclusion” because there is nothing to conclude. This article also didn’t have an intention to compare GraphQL with anything – even when I do comparisons with REST here and there.

The idea was to introduce this technology to newcomers, and also for those who already knew about it, talk about it from the perspective of a Delphi developer, hoping that I had clarified some points that might be obscure for those used to Delphi – I tried to focused exactly on the points that got me confused when I started learning about GraphQL.

What about you? Do you have any experience with GraphQL? Are you using it in production? What do you think about it? Are you a newcomer and want to ask something or share your doubts? Please leave your comment following the link below and let’s discuss about it!

Discuss about this article in our forum!

Detecting memory leaks is a very important task in Delphi development. I’ve written about it before, stressing that in server applications like the ones built with TMS XData this is even more important.

With the upcoming release of Delphi 10.4 version, this will become even more relevant. A unified memory management has been promised since last year, and it looks it has arrived.

As everything in life, this change isn’t 100% good or bad, there are pros and cons in it, but one thing is clear: the way memory is managed now is the same in all platforms, so the ways to detect memory leaks in different platforms are more similar now. I personally think this is a good thing. It’s also important to note that this doesn’t necessarily mean “more leaks” in mobile platforms. The “old” (still valid when I’m writing this article) ARC mechanism also had its problems, and in my opinion harder to detect, like dealing with cyclical references.

But well, enough with this too long introduction. The humble purpose of this article is to be a definitive and up-to-date list of all tools that you can use to detect memory leaks in Delphi applications. Pointing out that memory management is unified just means that these tools are even more relevant than ever. Detecting and fixing a memory leak in Windows will help even more that your non-Windows applications will not have memory leaks as well.

So, to the list!

FastMM (Free)​

FastMM (or to be more specific, FastMM4) is the de-facto standard tool to detect memory leaks in Delphi. The reason is simple: it’s the default memory manager in Delphi, so it’s already built-in and ready to use.

Since FastMM allocates and deallocates memory in your application, who else is better to report the blocks that have not been deallocated? All that it takes to start working with it is add a single line in your project:

ReportMemoryLeaksOnShutdown := True;

And voilà, your application will report all memory leaks when it shuts down. If there are leaks at the end of your application, a dialog will be displayed showing all the leaks.

All Delphi developers should add that line to their applications. Really. I don’t even know why this is not added by default in Delphi, at least wrapped by a {$IFDEF DEBUG} directive. Maybe for historical reasons.

So, if it’s built-in, default, works, why don’t we finish this article here, then? Well, there are some gotchas.

Delphi includes a stripped out version of FastMM4. It doesn’t have all the nice debugging tools you need (to know, for example, where in the code your leaked memory was allocated). To do that, you have to use the full FastMM4 version, available on the FASTMM4 public GitHub repository.

You also have to use a DLL for the full debugging features; it’s not cross-platform: it only officially works for Windows (it looks like a macOS version is available in the official repo, but I never tried it). And even though it has lots of features, to use it you have to deal with .INC files and manual configurations to make it work, which might not be comfortable for some users.

But all in all, is a great tool, the “standard” tool to get memory leaks in Delphi. (Side note: FASTMM5 has just been released. We haven’t tested it yet but it looks like it brings a great improvement in performance for multithreaded applications, we can’t wait to test it in TMS XData.)

Pros

• Free;
• Full source code;
• Built-in in Delphi;
• Easy to setup;
• Lots of advanced features.

Cons

• Windows only;
• Needs external DLL for debugging features;
• Not user-friendly to setup and use advanced features (no built-in GUI);
• Only reports leaks on memory allocated by FASTMM itself.

LeakCheck (Free)​

Delphi LeakCheck is another great option for detecting memory leaks. It’s also free, open source, and has some advantages over FastMM: it’s cross-platform, meaning you can check leaks directly in mobile and Linux applications; and it integrates very well with unit test frameworks (namely DUnit and DUnitX).

The way to get started with it is similar to FastMM: add LeakCheck unit as the first used unit in your dpr uses clause, and it will plugin and be ready to use. Setting up for unit testing is a little more complicated though, but that’s part of the game.

One small disadvantage is that to use it you are almost on your own: the project hasn’t received updates for a while (which isn’t necessarily bad since it’s working). But that means probably you won’t get much help directly from the author (I never tried, to be fair). There is also not much information about it in the web, I just found one single article that explains how to use it besides the detailed description in the official Bitbucket repository itself.

Pros

• Free;
• Full source code;
• Cross-plataform;
• Integrates well with unit testing (DUnit and DUnitX).

Cons

• Not much information around about how to use it;
• No recent updates, no official support;

Deleaker (Commercial)​

Delaker is the only commercial tool in the list that is exclusively dedicated to catch memory leaks. That reflects in the product, which provides you with really nice features for detecting memory leaks.

Differently from the previous two tools, and similar to the following ones, it has a friendly GUI for you to setup the environment and see the results, which can be used standalone or integrated to Delphi IDE. It can also detect way more types of memory leaks: GDI leaks, leaks of Windows USER objects and handles, leaks in Windows APIs, in 3rd party DLLs, etc. Exactly because of that, it provides options for you to easily ignore several types of leaks – if you don’t, you will get a gazillion of leaks in just a regular app execution.

Another nice feature is the ability to take snapshots of the memory allocation. This allows you to detect leaks not only during the lifetime of your whole application, but in some specific operations of it.

Pros

• Friendly GUI that can be used standalone or integrated into Delphi IDE;
• Detects all types of leaks;
• Command-line tool for CI integration;
• Memory usage snapshots;
• Official support;

Cons

• Paid license ($99 for Home License, $399 for Single Developer License);
• Windows only;

EurekaLog (Commercial)​

EurekaLog is an old player. It’s been around for decades – I couldn’t find any info on their web site about when first version was released, the oldest information is for EurekaLog 4.0 which was released in 2002, simply 18 years ago.

It’s not a tool dedicated exclusively to catch memory leaks. Instead, it has a full range of features, memory leak detection being just a “side” feature. The purpose of EurekaLog is to detect any problems in your application – exceptions, leaks, etc. – at the customer side, and report it back to you.

Thus, it’s a great tool to help you improve the quality of your software and provide good support to your customers, since you will get error and leak reports from all your customers, in different environments, doing different operations. It also helps you to find tricky bugs that only happen at customer side (you know it well, those “cannot reproduce it here” situations).

Pros

• Detects both memory and resource leaks;
• Leaks and errors detected at customer side can be sent automatically to you;
• Lots of other features: bug reporting, integration with bug tracking systems, among others;
• Official support;

Cons

• Paid license ($149 for Professional License, $249 for Enterprise License);
• Windows only;
• Not many advanced features for memory leak detection;

madExcept (Commercial)​

I use to say that MadExcept is the “cousin” of EurekaLog. They are both available for about the same time (around 20 years or more). They share similar features. They have more or less the same purpose. And so on.

And, funny enough, there isn’t a “winner”. If you look around the web about comparisons between the two, you will never come to a conclusion on which is “better”. Customers of both products are usually satisfied, and also usually they can’t comment on the competitor because they never used it. That’s my case, actually. I’m a happy EurekaLog customer (although I don’t use it to catch memory leaks), and I never used madExcept. But it could simply be the opposite. I believe I could be well served with madExcept as well.

Thus, I considered madExcept pros and cons equal to EurekaLog’s. Maybe the only visible different is that while madExcept is cheaper (there is even a free version for non-commercial use), EurekaLog seems to be much more active and frequently updated.

Pros

• Free for non-commercial support;
• Detects both memory and resource leaks;
• Leaks and errors detected at customer side can be sent automatically to you;
• Lots of other features: bug reporting, integration with bug tracking systems, among others;
• Official support;

Cons

• Paid license (€ 159 for full source license);
• Windows only;
• Not many advanced features for memory leak detection;

AQTime Pro (Commercial)​

AQTime is a top-notch tool to make your code better. It’s really high standard, offering not only an advanced memory leak detection tool (with a nice GUI, snapshots, memory tracking, resource leaks detection, among others) but also performance profiling (with both instrumenting and sampling profilers), code coverage, code analysis, among others.

It’s really awesome tool, but it has its downsides: it’s pretty expensive, and it looks in “maintenance” mode – it receives updates more or less once a year, and the news are mostly “support for the new Delphi version”. Handful bug fixes over the years, and virtually no new features. But well, it still has no equivalent tool in Delphi world when it comes to many and powerful features.

Pros

• Detects memory, resource, GDI, handle leaks among others;
• Real-time allocation monitor;
• Snapshots;
• Lots of other tools in the bundle (performance profiler, code coverage, etc.).

Cons

• Pretty expensive ($719 for a node-locked license, $2279 for node-floating license);
• Windows only;

Nexus Quality Suite (Commercial)​

In a similar way of EurekaLog and madExcept, I believe Nexus Quality Suite is somewhat related to AQTime. Both provide lots of tools to improve the quality of your software, and there are intersections between them.

Nexus Quality suite provides memory and resource leak detectors, but also performance profilers, line timers, code coverage, and even a GUI automatic tester, among other things.

I haven’t tried the memory check tool myself, thus the pros and cons will be just based on what I see from web site:

Pros

• Detects memory and resource leaks;
• Official support, active support forums;
• Lots of other tools in the package

Cons

• Paid license (AUD 490, around $300);
• Windows 32-bit only.

TMS MemInsight (Commercial)​

TMS MemInsight is an evolution from the former DDDebug. It’s a collection of debugging tools which contains several modules: a memory profiler, a thread viewer, a module viewer and an enhanced exception handler.

One interesting thing I noted from TMS MemInsight is that it has a slightly different approach, by providing memory usage and statistics instantly from inside the application. I didn’t use it but it looks like it makes it easier to find bugs in the app, by interacting with it at the same time you analyze it.

It also works with packages which is a plus, provides more functions besides just memory leak detection, and even though it’s commercial, the license price is really accessible.

Pros

• Provides results directly inside your application, from a GUI;
• Supports packages;
• Official support;
• Accessible license price (from €115).

Cons

• Windows only;

Spider (Free)​

Spider websites lists a lot of interesting features: analysis of exceptions, analysis of the realtime use of memory, analysis of memory leaks, analysis of the call stack, among others.

The thing is, from the list, is a tool I just tried once, and I got confused with the user interface and the results themselves. I couldn’t use it, but maybe that’s just me. So it’s listed here, but I can’t make any fair judgement over it.

Pros

• Free;
• Source code available;

Cons

• Confusing user interface (personal opinion);

Non-Delphi Tools​

In addition to the above tools that are Delphi specific, or at least also cover Delphi specifically – either integrating into source code, or in the IDE, etc. – there are also general-purpose tools for memory leak detection which can be helpful in some situations.

Valgrind (Free)​

Valgrind is an instrumentation framework. It provides many tools in it, and you can add your own. One of the tools is memcheck, which will help you to get leaks in your application.

I use it myself a lot to detect memory leaks in Linux applications, and it’s actually very simple to use: just execute valgrind and pass the application you want to test in the command-line parameter. Valgrind will launch the application and at the end of it will give you a report with detailed information including possible leaks. There are of course many command-line options you can use to log to a file, choose the size of call stack, detection level, among others.

Instruments (Free)​

Apple Instruments is a powerful and flexible performance-analysis and testing tool that’s part of the Xcode tool set. Among other things, it can be used to detect leak in iOS and macOS applications. Adrian Gallero has made a nice article at TMS Software blog about how to use Instruments to detect leaks in iOS applications. It’s a little bit old post already, but I believe it’s still valid.

Conclusion​

There is no winner. Each tool has their own pros and cons, and it’s interesting to note that the they are not mutually exclusive. Actually, I use several of them myself, for different purposes.

I use FastMM for my “daily” memory leak detection, LeakCheck in unit tests, Deleaker when I want to check for other types of leaks and use snapshots, EurekaLog for bug reporting in my end-user applications, AQTime for performance profiling and Valgrind for detecting leaks in Linux. As you can see, all of them are useful!

The important thing is: don’t let your application leak memory! If you are just starting with this subject, you know what to have to do now:

ReportMemoryLeaksOnShutdown := True;

Add the above line to your application and start catching leaks!

(Do you know of any other tool that should be on the list? Do you have a different opinion on the listed tools? Please comment below and share your knowledge to help make this list the definitive one. I will update it frequently as I receive new info.)

Discuss about this article in our forum!

This one is another one of many interesting discussions we had at the TMS Business Masterclass in Düsseldorf. One of then was the funny discussion about class fields having their name prefixed with uppercase “F” or not.

Now this one is a little bit more technical, but also interesting nonetheless. The session was about database data replication using TMS Echo, and the topic was how the changes are send (moved) from one peer (node) to another.

The question raised was about the “server”, or the “controller” which orchestrates all this “moving” of data changes. I replied that there is no “server” (in the sense that there is no central orchestrator, the system is distributed and can operate independent from other nodes), only to contradict myself few minutes later saying that a “server” is needed (but then I – hopefully – explained the contradiction).

A funny and interesting discussion, I hope you enjoy it, and, after you watch the video, I raise the question to you: Is there a server, or not? Leave your comment!

By the way, the complete content of the event is available here: TMS Business Masterclass Online.

Discuss about this article in our forum!

In November 2019, TMS Days 2019 took place in both Düsseldorf, Germany and Wevelgem, Belgium. It was the biggest TMS event ever, with three full days in two different cities, and team members from nine different countries around the world.

It was a face-to-face event and even before the event started many people from all over the world approached us asking if they could watch the content online since they could not travel to attend the event in person.

Well, now also for the first time, parts of a TMS event is now available to be watched online. You will have the opportunity to watch both TMS Business Masterclass days in full length – the one which took place in Düsseldorf and the one which took place in Wevelgem.

We also tried to provide you with high quality material:

• Audio from instructor is clear and the screen recordings are there, of course;
• A second camera showing the instructor is also present to give you a more immersive feeling and get a more personal touch;

• Questions from the audience was not very audible, but we took the effort to subtitle most of the questions so you could follow and understand everything that was being discussed!

• The full recording was fully reviewed and broken into several smaller pieces, so you don’t have a big chunk of 8 hours recording, but very small “lessons” and the subject discussed in each of them. Some are broken to the length of only a few minutes. So you can get really focused and productive on finding content!

Follow the links below to get more info about the course, pictures of the event, view the full course content structure, watch some preview videos for free, and of course, enroll to the course!

TMS Business Masterclass in Düsseldorf ($49)

TMS Business Masterclass in Wevelgem ($49)

TMS Business Masterclass Bundle ($79)

Enrollment is $79 for both courses, or just $49 for one course. Of course, all the attendants of the event in Düsseldorf or Wevelgem get free access, not only for the attended day, but for both. Another perk for the attendants!

To finish this post, watch this personal-favorite excerpt below. When building Delphi classes, do you prefix field names with an uppercase “F”? 😉

Discuss about this article in our forum!

Be prepared! Coming in November 2019, the biggest TMS Software event ever: TMS TRAINING DAYS 2019. TMS team members from nine different countries will be speaking about Delphi development, TMS libraries and components, in sessions that target from the beginner developer to the advance one.

Dusseldorf Training Days (Germany)​

On November 14th and 15th, there will be two training days in Dusseldorf, Germany. The event will take place at Lindner Hotel Airport, Unterrather Str. 108, 40468 Düsseldorf, Germany.

Check below the full agenda for the two training days

TMS Business Masterclass​

November, 14th – Dusseldorf, Germany

Bruno Fierens

9h00: Welcome & introduction (Bruno Fierens)

A welcome to all attendees and introduction to the agenda.

Wagner Landgraf

9h15: Session 1 – The TMS Business World (Wagner R. Landgraf)

A journey into the world of TMS Business bundle. We will learn about the solutions provided by TMS Business: the components included, the libraries, the use cases, all in the historical context and the motivations behind it. Products covered: TMS Scripter, TMS Diagram Studio, TMS Workflow Studio, TMS Data Modeler, TMS Aurelius, TMS Sparkle, TMS RemoteDB, TMS XData, TMS Echo, TMS Logging.
*BIZ level: Beginner

            10h00: Coffee break

10h30: The TMS Aurelius book , experiences & book writing process (John Kouraklis)

John Kouraklis book author talks about his most recent book dedicated to TMS Aurelius and the experiences related to writing it.

Wagner Landgraf

11h00: Session 2 – The Joy of Databases (Wagner R. Landgraf)

A talk about new ways to deal with databases. What is an ORM (Object-Relational Mapping) framework, and are the most recent news and features about it. What you can use to help you out in modeling your databases, easily use existing databases with the new paradigm, and advanced techniques on ORM and database modeling. Products covered: TMS Aurelius, TMS Data Modeler
*BIZ level: Intermediate

Wagner Landgraf

12h00: Session 3 – Your App Everywhere: REST API (Wagner R. Landgraf)

Multitier, cloud, REST, HTTP, SSL: What, Why, When, and mainly, How? Learn what a REST API server means, why you will benefit from moving your app to the cloud, and learn how to do it in a very RAD way. The latest features will be covered, even for the experienced users. Products covered: TMS XData, TMS Sparkle
*BIZ level: Intermediate

             13h00: Warm lunch

Wagner Landgraf

14h00: Session 4 – The Unsung Heroes (Wagner R. Landgraf)

A deeper look into three awesome TMS Business libraries that bring you solutions for problems you never thought you had. User-customized application, modifying business rules at runtime, offline data synchronization, and moving your app to the cloud in a couple of days. Products covered: TMS Scripter, TMS Echo, TMS RemoteDB
*BIZ level: Beginner

Wagner Landgraf

15h00: Session 5 – Getting serious in the Cloud (Wagner R. Landgraf)

Advanced techniques and concepts when building REST API servers: Security, background processing and deep analysis of real-world source code. Products covered: TMS XData, TMS Sparkle
*BIZ level: Advanced

             16h00: Coffee break

Wagner Landgraf

16h30: Session 6: All Together Now (Wagner R. Landgraf)

A very interactive session where all the current ideas from the TMS team for the future of TMS Business will be presented. We will discuss the existing roadmap, brainstorming about all the possibilities, have all questions answered and summarize the whole day.

             17h30: Wrap-up, Q&A & open discussion 

TMS DEV Intensive​

November, 15th – Dusseldorf, Germany

Bruno Fierens

9h00: Welcome & introduction (Bruno Fierens)

A welcome to all attendees and introduction to the agenda.

Bruno Fierens

9h15: TMS VCL UI Pack modernization (Bruno Fierens)

What is new & upcoming for ensuring VCL UI controls look as good as possible: high-DPI, VCL styles, Office styles, images

Marion Candau

10h15: Using TMS Cryptography Pack for secure signing of PDF files (Marion Candau)

Marion will show how to sign a PDF document with a cryptographic USB token using TMS Cryptography Pack. She will briefly explain the cryptographic mechanisms of an electronic signature, then she will present how a cryptographic USB token works and finally, how to use a TMS Cryptography Pack component to sign a PDF document with the token.

           10h45: Coffee break

Adrian Gallero

11h15: TMS Flexcel 7.0 introduction: taking advantage of the new Flexcel 7.0 for VCL/FMX features (Adrian Gallero

Adrian will show how to create a Delphi app that exports data to Excel and Pdf files, using some of the newest stuff introduced in FlexCel 7. If time allows, he will also have a glimpse at the future and look at the stuff currently in development.

           12h15: Warm lunch

José León Serna

13h15: Taking the wraps of our upcoming groundbreaking product for Delphi developers (José León Serna / Bruno Fierens)

Be there, be amazed, receive the first product beta and start playing with it! It has been more than one year that Bruno Fierens, CEO of tmssoftware.com got in touch with José Leon Serna and discussed about future opportunities for Delphi development. Surprisingly our visions for future directions and possibilities perfectly aligned. From there, an intense collaboration started and in this session they will present the first fruits of this collaboration. TMS clearly could not have achieved the amazing technical break-throughs without José Leon. The TMS team is honoured, happy and proud to have one of the brightest minds in the Delphi world in our family.

Roman Yankovsky

14h15: Using TMS FixInsight to bring your code to a higher & more secure level (Roman Yankovsky)

Roman will show how to use FixInsight’s static code analysis in Delphi to find bugs in your code before your customers do.

           15h15: Coffee break

Roman Kassebaum

15h45: TMS WEB Core v1.3 for web, cross platform Electron and mobile PWA apps new features & capabilities (Bruno Fierens / Roman Kassebaum)

Together with Bruno Fierens, Roman Kassebaum, architect of the TMS WEB Core IDE integration, will present and demonstrate TMS WEB Core v1.3 new features & capabilities.

Holger Flick

16h45: Putting it all together : Using TMS XData back-end and TMS WEB Core + TMS FNC UI as front-end (Holger Flick)

Many frameworks, many platforms: TMS has all the tools. You’ve read it many times, but how do all these technologies fit together? This session will give an example of how you can build a database application for multiple desktop and mobile platforms as well as for the web using the same database backend. It will also provide an overview of the technologies that are available from the TMS toolbox and will hand you key pointers how to pick the right one for the task you need to achieve. In short, you will get a hands-on example that covers TMS XData, TMS RemoteDB, TMS Web Core, VCL, and FNC.

           17h45: Q&A & open discussions 

Meet the experts

During the whole TMS Dev Intensive Day, the opportunity will be given, as alternative to the regular sessions, to meet each of the many TMS experts available during the full day in person or in very small group to discuss and learn from.

Wevelgem Training Day (Belgium)​

On November 18th, there will be a second TMS Business Masterclass day in Wevelgem, Belgium. The event will take place at the TMS Software Main Office. It’s an opportunity to meet other members of the team as well!

The sessions will very similar to the TMS Business Masterclass in Dusseldorf on November 14th, thus this is a simplified agenda. All sessions will be presented by Wagner Landgraf and Bruno Fierens.

TMS Business Masterclass​

November, 18th – Wevelgem, Belgium

Speakers:

Bruno Fierens

Wagner Landgraf

9h00: Welcome & introduction (Bruno Fierens)

9h15: Session 1 – The TMS Business World (Wagner R. Landgraf)

10h00: Coffee break

10h30: Session 2 – The Joy of Databases (Wagner R. Landgraf)

11h30: Session 3 – Your App Everywhere: REST API (Wagner R. Landgraf)

12h30: Warm lunch

13h30: Session 4 – The Unsung Heroes (Wagner R. Landgraf)

14h30: Session 5 – Getting serious in the Cloud (Wagner R. Landgraf)

15h30: Coffee break

16h00: Session 6: All Together Now (Wagner R. Landgraf)

17h00: Wrap-up, Q&A & open discussion

SPEAKERS​

Adrian Gallero (Uruguay)
Adrian Gallero is an Electrical Engineer who has been working in Delphi since it was Turbo pascal 4. He has worked in calculating power line distribution for electrical companies in Montevideo and Rio de Janeiro. He lived for over 3 years in Madrid working the development of a telecommunication management system, and over a year in Sydney developing custom solutions for a freight-forwarding company.

He has been working with spreadsheets for longer than he can remember, and in 1996 he developed a small component that allowed his Delphi 1 apps to export the results to a spreadsheet (to his surprise, he learned a year ago that the electrical company is still using those unmodified apps today). This component grew over the years: It was renamed FlexCel in 2001 and it joined the TMS family in 2002. Today FlexCel exists in both Delphi and .NET versions, and they contain over a million lines of code.

Bruno Fierens (Belgium)

• Studied civil electronic engineering at university of Ghent, Belgium (1987-1992).
• Started a career as R&D digital hardware engineer at Barco Graphics Belgium designing with FPGA, VHDL, graphic processors, PCI, Silicon Graphics add-on boards, high-end printer controllers,…
• Began writing software in Turbo Pascal 3.0 since 1987 and used all Borland Pascal and all Delphi versions since then.

• Founded TMS software in 1996, developing VCL components starting with Delphi 1.
• TMS software became Borland Technology Partner in 1998 and developed Delphi Informant award-winning grid & scheduling components.
• From 2011 FireMonkey cross platform components,targetting Windows, macOS, Android, iOS.
• In 2016, TMS software launched FNC, a framework neutral component architecture enabling to use UI controls in VCL,FMX & LCL apps
• In 2018, TMS software launched TMS WEB Core, a framework for creating rich web clients using ObjectPascal
• Currently doing and managing VCL, FMX, Web, .NET, IoT, LCL, REST, node.js development.
• Is a regular speaker at conferences (Be-Delphi, DelphiTage, ITDevCon, CodeWay Tour, EKON, DevTracks, SDN, ..).
• Available for consulting & custom project development.
• Bruno Fierens was titled Embarcadero MVP since 2012.
• Special area of interest are user interfaces design, UX, RAD software development, hardware/electronics.

Holger Flick (United States)
Since 1996, Dr. Holger Flick has been using Delphi as his primary development platform and has been an active member of the community. He studied computer science at Dortmund University and later wrote his dissertation at the Ruhr University in Bochum in the field of telemedicine. For his passion for and knowledge of Delphi he was awarded the “Delphi MVP” moniker in 2016.

In 2019, Holger moved to the United States of America (USA) and established his new company FlixEngineering LLC. The company focuses on consulting, training and software development using object-oriented programming languages like Delphi, C#, Swift, and Objective-C. Holger is part of the TMS Software family providing his expertise as Evangelist and QA Engineer.

John Kouraklis (United Kingdom)
John Kouraklis started exploring computers when he was 16 and since then has followed all the way from Turbo Pascal to the latest Delphi versions as a hobby initially and as a profession for most of his adult life. He has developed a wide range of applications, from financial software to reverse engineering tools. The last years he has been teaching business and programming in undergraduate and postgraduate courses. He is the author of MVVM in Delphi (Apress, 2016) and

Introducing Delphi ORM – ORM with TMS Aurelius (July 2019)

José León Serna (Spain)
JCreator of Delphi for PHP/HTML5 Builder and former Director of Engineering and Branch Manager at Embarcadero Technologies between 2010 and 2016. Although the Embarcadero’s branch participated in the development of several products, he was mainly responsible for RAD Studio, and more specifically, the IDE. He participated actively on the conception and implementation of multitude of new features, specially focused on multi-device development. He has been

involved in IDE development for most part of his career and is the area where he enjoys most.

Marion Candau (France)

• PhD in cryptography
• Developer at Cyberens, a French cybersecurity company located in Bordeaux.
• TMS Cryptography Pack architect
• MVP Embarcadero
• She mainly develops cybersecurity-related applications and advises clients to use cryptographic tools and libraries in their own applications.

Roman Kassebaum (Germany)
Roman Kassebaum is a freelancer. He started to work with Delphi in 1996 after he graduated with a Master degree from the University of Paderborn. He is a Delphi MVP and an Embarcadero Technology Partner. During the last years he became a member of the great TMS team and he is also a TMS certified consulting partner. Roman is a specialist in all kinds of Delphi projects including TMS Business components and the cutting edge TMS WEB Core library for which he created the Delphi IDE integration.

Roman Yankovsky (Russia)
Roman Yankovsky is an Embarcadero MVP who has been working with Delphi since Delphi 2. He joined the TMS team in 2016. He is the product manager and architect of the FixInsight static analysis tool for Delphi.
Roman Yankovsky is also author of the Delphi AST, an open source Abstract syntax tree builder for Delphi you can find here: https://github.com/RomanYankovsky/DelphiAST and this library is used in the great OmniPascal Visual Studio Code extension.

Wagner Landgraf (Brazil)

• Graduated in Electronic Engineering and M.Sc in Industrial IT at Federal Technological University of Parana-Brazil.
• More than 24 years experience (since 1995) in Delphi development – since Delphi 1.
• Architect and main developer of Delphi libraries like TMS Aurelius, TMS XData, TMS RemoteDB, TMS Scripter, among others.
• Product Manager at TMS Software for more than 20 years. Founder of landgraf.dev online school.

Special Bonuses​

There are also special bonuses for attendees of TMS Training Days!

Book: Introducing Delphi ORM

All attendees of TMS Business Masterclass day in Dusseldorf (Nov 14th) will receive a free copy of the book “Introducing Delphi ORM: Object-Relational Mapping using TMS Aurelius“, written by John Kouraklis. Wagner Landgraf, author of TMS Aurelius was a technical reviewer of the book.

“Introduction to TMS Web Core” Training Course: 50% off

All attendees of TMS Training Days will get a 50% off discount coupon for the online training course “Introduction to TMS Web Core”, from landgraf.dev. The instructor is Wagner Landgraf and you will learn concepts from the beginning: what is a web application, how does it work, what are single page application (SPA) and multiple page application (MPA), what is HTML, JavaScript, CSS, Bootstrap, AJAX. Full source code of the examples are provided.

Special discounts for TMS Products

TMS Software will also offer special discounts for new license on several TMS products, for all attendees. Stay tuned for the offers!

Registration and More Info​

You can find more info from TMS Software web site directly: TMS Training Days in Dusseldorf and TMS Business Masterclass in Wevelgen.

Registration fees:

Nov 14th, TMS Business MasterClass: 295 EUR Nov 15th, TMS Dev Intensive: 295 EUR Nov 18th, TMS Business Masterclass: 295 EUR

Special offer for the two TMS Training Days in Dusseldorf (Nov 14th and 15h): 495 EUR

Register Now for Dusseldorf Days!

Register Now for Wevelgem Day!

On October 22nd, 2019, there will be another edition of Embarcadero Conference. It’s the biggest Delphi event of the world, and happens in São Paulo, Brazil. There are hundreds of attendants.

In this edition, just like last year, there will be seven simultaneous sessions, all happening in the same auditorium. You choose which session to listen by selecting the audio channel in your headphones. The full session list is available in the site of the event.

With som many sessions happening at the same time, you get even anxious to choose which want to watch. But if there is one that you cannot miss, it’s this one we are going to suggest.

Our speaker, Wagner Landgraf, will be presenting the session “Anatomy NFC-e issuer in the cloud (REST API). Oh yes, we are recommending our own session. But that’s just a coincidence, it will be very interesting, believe me!

Why “in the cloud”?​

Ok, let’s anticipate some content here. Why of the reasons is the “why”. NFC-e is a legal digital document in Brazil, and when we issue such a document in the cloud, we have several advantages compared to the issuing of the same document in a local desktop or mobile application:

• One single and centralized place to configure the issuing environment (installation of certificates, configuration of cryptography libraries, etc.)

• Minimizes the risk of problems and support cost: you don’t have to configure hundreds of client environments

• Much easier system update and maintenance: you also don’t need to manage all the clients.

• You can issue NFC-e from any platform (from a desktop Windows application, a mobile application, or even from Rasperry PI, who knows?). All you need is internet connection and HTTP communication on that platform.

• t’s easier to develop clients in other platforms. No need to be able to port and compile several 3rd party libraries needed for the document issuing, like ACBr, FastReport, FortesReport, cryptography dlls or tools, etc.

Can you disclose a little bit more?​

To give you a tease of what will be presented, here are some screenshots of the API that we will show and explain at the event:

Not only that…​

This will be a really interesting session. There will be an additional surprise that for sure will be very interesting for all those who work with Delphi and deal with such legal Brazilian documents. That’s just the beginning… See you at Embarcadero Conference 2019!

Discuss about this article in our forum!

On October 10, Softacom is holding a webinar on “Databases inside RAD Studio & Delphi ecosystem. Migration process (legacy to up-to-date, to another RDBMS), data layer architecture (ORM), data access architecture (REST API)”.

Speakers​

Wagner Landgraf from landgraf.dev will be one of the speakers, talking about how database access evolved in Delphi since the early versions, Object Relational Mapping (TMS Aurelius), REST API Servers (TMS XData) and remote database access (TMS RemoteDB).

Serge Pilko

Embarcadero MVP & CEO of Softacom – Enterprise digital transformation & software modernization services expert

Wagner Landgraf

CEO of landgraf.dev / TMS Software Partner / TMS Business Product Manager

Bruno Fierens

Embarcadero MVP & CEO of TMS Software – Main player as Delphi and C ++ Builder 3rd party vendor

What will you learn​

For CEO / Owner / CTO / IT – Director / Product Manager:​

• Up-to-date Delphi solutions and frameworks for communications with databases;

• Pitfalls of migration to up-to date or another type of RDBMS;

• Cutting-edge Delphi-related solutions and practices for RDBMS;

• Arguments, why you have to use Delphi and RAD Studio for your multi-tier applications;

For Developers and Technical Specialists:​

• Best practices for developing data access layers for RAD Studio projects;

• How to use ORM for Delphi projects;

• How to develop REST API server as DB facade;

• Insights, tips and tricks for the app developers from the first mouth of DB tools and DB framework developers;

Webinar Highlights:​

• Most popular data access patterns 10-15 years ago and today;

• Pitfalls of migration legacy versions of RDBMS to up-to-date versions;

• Pros and cons of migration to ORM instead of using regular practices;

• ORM for Delphi ─ TMS Aurelius from TMS Software. Pros and cons of the solution;

• Pros and cons of migration to REST API instead of using “classic” DB access;

• REST API server for Delphi ─ RAD server. Pros and cons.

For webinar attendees only!​

Don’t miss a chance to get your discount promo code for EKON conference and 10% discount for new TMS Software licenses.

Registration​

Registration link: https://www.softacom.com/en_softacom_october_webinar

Discuss about this article in our forum!

Inline variables declaration is a feature introduced in Delphi Rio 10.3. What is it?

In short, it is the possibility to declare a variable in any line of your code. That is, you can declare a variable this way, within the begin..end block:

procedure Test;
begin
  var I: Integer;
  I := 22;
  ShowMessage (I.ToString);
end;

A lot of people already understood how this feature works, but did not understand why it is interesting. In this article, I will show you this new feature with a focus on the advantages it brings.

1. Organizes your code​

The variable is only accessible from the point it is declared. For many people this better organizes the code in a large method, because it is possible to know better where that variable is being used. Consider the following code:

procedure Test;
var 
  A, B, C, D, E: Integer;
  Found, Done, Excluded: Boolean;
  Text: string;
begin
   // many
   // lines
   // of
   // code
end;

Update (May 18, 2020): Darian Miller provides even more benefits of using inline variables in his nice blog post “Newly discovered hidden benefits of inline variables in Delphi“.

2. Minimizes bugs​

Have you ever done something like this:

procedure Test;
var I: Integer;
begin
  for I := 0 to Count - 1 do
    Process;
  DoSomethingWithI(I);
end;

That is, using the for variable after the loop is finished. This is not safe, and although the compiler raises a warning for this, many people ignore it. By declaring the for variable inline, it will be only valid inside the for, and using it outside the block will result in a compilation error:

procedure Test;
begin
  for var I: Integer := 0 to Count - 1 do
    Process;
  DoSomethingWithI(I); // Compile error!!!
end;

The benefit from the code above comes from the fact that the scope of the variable is limited to the block in which they are declared. That minimizes the chance of errors. For example, suppose you have a code like this:

procedure Test;
var I: Integer;
begin
  I := CalculateSomething;
  Persist(I);
  // many lines below...
  Log(I);
end;

Then you eventually need to refactor the code in a way that the first part only executes under a specified condition. You think that variable I is only being used there, and do something like this:

procedure Test;
var I: Integer;
begin
  if Condition then
  begin
    I := CalculateSomething;
    Persist(I);
  end;
  // many lines below...
  Log(I);
end;

There, you forgot the last line and maybe the value of I is not what you expect. Changing the scope of your variable to the block will generate compilation errors if the variable is used outside the block, which will show you the problem immediately, so you can make a decision:

procedure Test;
begin
  if Condition then
  begin
    var I: Integer;
    I := CalculateSomething;
    Persist(I);
  end;
  // many lines below...
  Log(I); // Compile error!
end;

3. Less typing​

Who does not want more productivity? If you can type a bit less to declare a variable, why not? You can now declare and initialize a variable at the same time:

procedure Test;
begin
  var I: Integer := 22; 
  ShowMessage (I.ToString);
end;

But not only that. There is also type inference, which means that in most cases you do not need to include the variable type when declaring it. Just initialize the variable with a value and Delphi will know the variable type.

Looks like it’s not a big deal? Imagine a case where the variable type is using heavy generics:

procedure NewTest;
var
  MyDictionary: TObjectDictionary<string, TObjectList<TMyAmazingClass>>;
  Pair: TPair<string, TObjectList<TMyAmazingClass>>;
  List: TObjectList<TMyAmazingClass>;
begin
  MyDictionary := TObjectDictionary<string, TObjectList<TMyAmazingClass>>.Create;
  MyDictionary.Add('one', CreateList);
  Pair := MyDictionary.ExtractPair('one');
  List := Pair.Value;
  ShowMessage(List.Count.ToString);
end;

Using inline variable and type inference, you can rewrite the code this way:

procedure NewTest;
begin
  var MyDictionary := TObjectDictionary<string, TObjectList<TMyAmazingClass>>.Create;
  MyDictionary.Add('one', CreateList);
  var Pair := MyDictionary.ExtractPair('one');
  var List := Pair.Value;
  ShowMessage(List.Count.ToString);
end;

Better, isn’t it?

4. Increases performance​

The fact that the variables belong to a more limited scope (within a begin..end block) can even increase code performance!

You can see more details in this excelent article: Inline Variables can increase performance. In summary: the variable will initialized only if the code execution enters the block, and finalized only upon block exit. In this code, for example:

procedure TestInlineVars(const ACondition: Boolean);
begin
  // BEFORE
  if (ACondition) then
  begin
    var S := 'Inline String';
    var I: IInterface := TInterfacedObject.Create;
    var F: TFoo;
    F.S := 'Managed Record';
  end;
  // AFTER
end;

Variables S, I and F are managed types (string, interface and record). The compiler automatically adds initialization and finalization code for them.

If you call TestInlineVars procedure a million times, it will have a big impact. However with the code above, the variables will only be initialized if ACondition is true and the block is actually executed. Less unnecessary code being executed.

5. Makes it easier to use conditional directives​

This feature can help even in small things. This article brought my attention: Unexpected Benefit of Inline Variables: Conditional Blocks.

If you use compiler directives where you declare and use different variables for each situation, you have also wrap variable declarations around a compiler directive as well:

procedure DoesSomething;
var
  {$IFDEF CASE1}
  var1: Integer;
  {$ENDIF}
  {$IFDEF CASE2}
  var2: Integer;
  {$ENDIF
begin
  {$IFDEF CASE1}
  // use var1
  {$ENDIF}
  {$IFDEF CASE2}
  // use var2
  {$ENDIF}
end;

Boring, huh? In my opinion this is easier:

procedure DoesSomething;
begin
  {$IFDEF CASE1}
  var1: Integer;
  // use var1
  {$ENDIF}
  {$IFDEF CASE2}
  var2: Integer;
  // use var2
  {$ENDIF}
end;

I believe that inline variables still brings other subtle benefits in specific situations that are not listed here. If you can think of any other benefit, leave your comment. If you do not agree and you think inline variables are not good news for Delphi, leave your comment as well. Just do not forget one thing: if you didn’t like it, simply don’t use it!

Discuss about this article in our forum!

Embarcadero has just released a new Delphi Rio version (which means also Rad Studio and C++ Builder): version 10.3.2. It’s a minor update – meaning product codename is still “Rio”, and it’s binary (DCU) compatible with previous 10.3.1 version.

Why then, an article about a minor update? Usually minor updates contain just bug fixes and small improvements, however it’s not the case of this one. I will mention here two improvements that I personally found significant. It’s also worth mentioning that Embarcadero has recently published the updated Rad Studio roadmap – May 2019 which lists the probable new improvements in upcoming major versions. Now to the improvements in this release:

macOS 64-bit support​

Delphi 10.3.2 finally supports macOS 64-bit platform. If you develop macOS applications with Delphi, you know how much this is important.

Apple has been planning moving all macOS applications to 64-bit for years and informing users and developers that 32-bit macOS applications will be deprecated soon. And the time has come. When using macOS Mojave and trying to run 32-bit applications (the ones built with Delphi until 10.3.1, for example), users are receiving the following message:

I would say that your application wouldn’t give much confidence to the user, do you agree? And, finally, in next macOS release, macOS Catalina (10.15), 32-bit applications will simply not work anymore.

Thus, if you develop (or intend to develop) macOS applications with Delphi, it’s a relief to know that you won’t have those problems anymore: just build 64-bit macOS applications and everything is going to be alright!

IDE stability and performance​

Another improvement that is worth mentioning is the significant improvement in IDE stability and performance. First Delphi Rio version brought us a refreshed IDE, with dark theme and more modern visual. But there were also issues: flickering, strange visual “effects”, slowness, the screen was redrawn several times when you resized the window, among other things.

That was significantly improved in this new update. If you are already using previous Delphi Rio 10.3 or 10.3.1, I believe you will notice the difference, with a smoother and snappier IDE in this regard.

Delphi Rio 10.3.2 is already available! There are many other improvements besides the ones mentioned above. If you are already using this new update, leave a comment telling what do you think about it!

Discuss about this article in our forum!

A memory leak happens when your application allocates a space in memory and never frees it again.

How memory leaks happen in Delphi​

In a Delphi application, memory spaces are allocated and released all the time. This is often done automatically by the compiler or by the RTL – for example, when allocating variables of primitive types, parameters that are passed to functions, etc. – and we usually do not have to worry about it.

However, there are many cases where we allocate memory manually. Instantiating an object is one of them:

Obj: = TMyObject.Create;

The code above will allocate a memory space and the Obj variable will point to the address of allocated memory space. To release it, you can use the Free method:

Obj.Free;

If the developer forgets to call the Free method, the memory space associated with the object is never released. We have a memory leak.

Consequences of memory leaks​

You may wonder: "What’s the problem? I’ve seen this happen in my application and I’ve never had any practical problems!"

Actually, we often don’t see issues when there are just a few memory leaks, and the consequences also depend on the type of applications:

Client applications (desktop or mobile)​

In general, in desktop or mobile applications, the consequences are not very serious. In current operating systems, the memory allocated by the application is generally released when the application is terminated, so as not to cause system instability.

Even so, if your application generates a lot of memory leaks, there may be some problems, caused by excessive memory usage:

• Slow application and/or system: Disk access may be necessary to get around the memory shortage.

• Application abrupt closing: The operating system may force application termination due to excessive memory usage. This is more common in mobile applications.

• Application bugs: Application code that allocates memory can start to crash and cause bugs.

Server Applications​

When talking about server applications, the problem gets worse. That’s because ideally you will never close the server – you want it to run "forever" without needing to restart it.

The consequences are almost the same as the ones for desktop applications, but since the server application theoretically should never close, any small memory leak will have consequences in the future. The memory will slowly be consumed over days, weeks, months, and your server performance will degrade, bugs will appear and eventually the server will stop working.

Avoiding Memory Leaks​

There are techniques and tools to help you detect and remove memory leaks from your application. This will be covered in future posts.

What about you? Have you ever had issues in your application caused by memory leaks? Do you consider detecting and removing memory leaks a low-priority task compared to other more important things to worry about in your code? Leave a comment!

Discuss about this article in our forum!