Leaderboard

I decided to make a release version of TaurusTLS available at: https://github.com/JPeterMugaas/TaurusTLS/releases/tag/1.0.0.36 It has been over a year since I've started TaurusTLS and I feel it time for a release version. This version supports Delphi versions from Seattle to Florance as well as the following Operating Systems: Android iOS Linux MacOS Windows Windows .DLL's and static libraries for Android, iOS, and MacOS are available at: JPeterMugaas/OpenSSL-Distribution: OpenSSL Distribution for TaurusTLS

I think the 32 bit dll you're using are too much old. Try those: https://www.postgresql.org/ftp/odbc/releases/REL-17_00_0006/ You need all those 32 bit DLL in one folder: Push in your DataModule a TFDPhysPgDriverLink and SET VENDORLIB to the directory where the 32 bit dll are. Now your are able to use you design components inside the IDE. At runtime simply change the VENDORLIB with the correct value (where 64 bit dll are),

I know I am late to the party, but the slowness of this forum during the last days made me think twice before posting anything. First let me tell you that I am in the concise project party - I can take a vanilla Delphi installation, pull and check out a project repository and have all dependencies inside the project folder structure using Git submodules. This turned out to be the most effective approach allowing individual branches holding project specific tweaks. Usually I have the global IDE library path reserved for Delphi units only. This forces me to actively add any newly used library to the submodules and project search path, which always starts a reasoning whether the inclusion of that library is actually worth it. The latter keeps the dependencies low on the long run. In the past, mostly for simplicity, I added the source paths for these projects, requiring to compile all libraries with each build. This counts for each project, because each uses a different Unit output directories to keep the compiled units separated (think of different conditionals). Unfortunately, since a couple of years we have had some Delphi versions that forced me to start a complete build more often than I anticipated. That raised my interest in the concept of pre-compiled units. To get some numbers to compare the benefits of this approach I took a project group of some relative small projects, changed that to pre-compiled units and compared the build times and other performance changes when working with the project. First I needed to create a batch that actually does the pre-compilation after checking out the libraries. I didn't expect that to be the task taking the most effort. To be Delphi version agnostic I had to prepare proper packages and project groups for some libraries. Then I created an MSBuild project file with the project groups of all used libraries, so that I can call MSBuild once for a platform and configuration in a batch file with MSBuild using BuildInParallel, setting DCC_DcuOutput to a common folder. Having this all working correctly (I had to add copying the .dfm and .res files to the project, too), the time to build all libraries for one platform and configuration lasts about 15 seconds, adding up to a less than half a minute for Win32 and Debug/Release. For simpler maintenance of the project search paths I already used an option set, so changing the list of all the the libraries source folders to the one dcu folder was quite a simple task. It even survives changing to a new Delphi version: ..\lib\dcu\$(ProductVersion)\$(Platform)\$(Config) (As some may note: I have all projects a the source root allowing to have the same relative folders). The build time for one of the most used projects reduced from ~10 seconds to ~4 seconds. That doesn't sound much, but it adds up. And it has way more consequences during working at the code. I rarely see the CodeInsight progress bar anymore and when it is just for a glimpse. Also LSP seems much more stable and has to be restarted less often. (Sometimes restarting doesn't even help and it turns out I actually made a mistake myself.) More and more I get away with a plain compile instead of a build. (Probably I only do a build out of habit) MMX Source Indexer is much faster. Instead of 3000 files it now has to scan just 600. All these effects, even if each is small, add up to a significant faster and smoother working experience. I am aware that using the IDE library path approach includes some of these benefits, too. Nevertheless, I still prefer the concise project approach. Also I want to avoid having libraries in the search paths for all projects of which only a small part makes use of.

The issue has been identified: Microsoft Edge registers a global hotkey for Alt + Shift + S. This behavior has been corrected in the latest version of Edge, so updating the browser resolves the problem.

* They just removed major features in this latest version.

Hi All We just released an update to FinalBuilder which includes support for Delphi and C++Builder 13.0, along with support for Visual Studio 2026 (insiders release). FinalBuilder is a powerful automation tool for building, testing, and deploying software without writing complex scripts. It provides a visual interface to define build workflows with hundreds of built-in actions. Use it to streamline repetitive build tasks, ensure consistent releases, and integrate seamlessly with CI servers. https://www.finalbuilder.com/finalbuilder

Since this topic just came up again: Actually, bookmarks are tied to a specific character position, so not just the line but also the column. For Breakpoints it's only the line number. GExperts tries to preserve both by keeping track of the positions of the tokens.

If you let your subscription lapse then they charge you full price for a new license because they are unscrupulous and hate their customers

I use Pascal Analyzer. It is a great application for detecting both small and large mistakes that can occur. Now I got WARN53. From doc at https://www.peganza.com/PALHelp/index.html?warnings_report.htm WARN53-Mixing interface variables and objects This section reports locations in your code with assignments between objects and interface variables. Normally, unless you really know what you are doing, it is a bad idea to mix interfaces and objects. The reason is that the reference counting mechanism of interfaces can be disturbed, leading to access violations and/or memory leaks. Example: My method. TBoldMember is a class in Bold for Delphi function TModificationHistoryTracker.GetOldLink(ABoldMember: TBoldMember): TBoldObject; var StringRepresentable: IBoldStringRepresentable; OldValue: IBoldValue; begin OldValue := ABoldMember.OldValue; if Assigned(OldValue) then begin if not Supports(OldValue, IBoldStringRepresentable, StringRepresentable) then raise EModificationHistoryTracker.Create('Unsupported value type.'); Result := GetApplicationKernel.MetaSystem.GetObjectForIdString(StringRepresentable.asString); end else Result := nil; end; I also asked Claude, and it claimed that this could be a problem, as both Bold may free the memory. When OldValue goes out of scope, the reference becomes 0, and another free operation occurs. So the same memory is freed twice. The solution would be to remove the temporary variable OldValue. I have to say that I am confused. Is the code OK or bad? Here is the text from Claude: The Core Issue: Two Different Memory Management Models Delphi has two fundamentally different ways of managing object lifetime, and your code is mixing them in a way that can be dangerous. Object references use manual memory management. When you create an object with TMyObject.Create, you own that object and must explicitly call Free to destroy it. The object exists until you explicitly destroy it, regardless of how many variables point to it. Interface references use automatic reference counting. When you assign an object to an interface variable, Delphi automatically tracks how many interface variables are pointing to that object. When the last interface reference goes out of scope, Delphi automatically destroys the object. What's Happening in Your Code Let's trace through your code step by step: OldValue := ABoldMember.OldValue; The property ABoldMember.OldValue is declared as returning IBoldValue, which is an interface type. However, internally, the Bold framework is managing actual objects (probably instances of TBoldValue or a descendant class). These objects are owned and managed by the Bold framework itself using its own lifecycle management. When you assign this to your OldValue variable, something subtle but important happens. Delphi performs an implicit cast from the object to the interface. This cast does several things behind the scenes: First, Delphi calls QueryInterface on the underlying object to get the IBoldValue interface pointer. Second, and this is the critical part, Delphi increments the reference count on that object. The object now thinks it has one interface reference pointing to it. Why This Creates a Problem The Bold framework created and owns that TBoldValue object. It's managing that object's lifetime as part of its domain model. The framework expects to be in control of when that object lives and dies. But now you've created an interface reference to it. When your OldValue variable goes out of scope at the end of the function, Delphi will automatically decrement the reference count. If that reference count reaches zero, Delphi will attempt to destroy the object. This creates a conflict. You have two different systems trying to manage the same object's lifetime. The Bold framework thinks it owns the object and will free it when appropriate. The interface reference counting system also thinks it has responsibility for the object. This can lead to several problems: The object might be destroyed prematurely while Bold still needs it, causing access violations later. Alternatively, if Bold manages to free the object first, your interface reference becomes a dangling pointer, and when it goes out of scope, Delphi tries to decrement the reference count on an already-freed object, causing a crash. In some cases, you might get a memory leak if the reference counting prevents Bold from properly cleaning up. Why Pascal Analyzer Warns Pascal Analyzer performs static analysis on your code. It sees that you're taking a property that returns an interface type and storing it in a local interface variable. It recognizes this pattern as potentially dangerous because it's mixing two incompatible memory management strategies. The analyzer is essentially saying: "I see you're creating a reference-counted interface reference to an object that might be managed by a different system. This could cause lifetime management conflicts." The Solution The way to fix this is to avoid creating the intermediate interface variable. Instead, use the property directly where you need it. This way, you're still working with the interface, but you're not creating a stored reference that participates in reference counting:

Hi All I created a Delphi implementation of ULID - A Universally Unique Lexicographically Sortable Identifier. ULID's are a better option than GUIDs where sorting is needed 128-bit compatibility with UUID 1.21e+24 unique ULIDs per millisecond Lexicographically sortable! Canonically encoded as a 26 character string, as opposed to the 36 character UUID Uses Crockford's base32 for better efficiency and readability (5 bits per character) Case insensitive No special characters (URL safe) Monotonic sort order (correctly detects and handles the same millisecond) https://github.com/VSoftTechnologies/VSoft.Ulid

Do you care about 3rd Party AIs and let the forum be slow as turtle ? Come on ... Block them!

I use 64bit Exe for a FireDAC VCL program with PostgreSQL 64bit database. This connects at design time using the RAD Studio 13 64bit IDE. (My app is C++ Builder but it is still using the FireDAC components to make the connection). Make sure you have a TFDPhysPGDriverLink component in a datamodule and that it has it's "VendorLib" property set to the full path to the libpg.dll. I believe the same approach will work with the 32 bit IDE provided the VendorLib property points to a 32bit dll that works with your database. But I never tried this as I didn't have the time/energy to rebuild a 32 bit version of the postgreSQL drivers for the database from scratch. I am not sure about using old postgreSQL drivers (that do exist in 32 bit mode) on a later version of the database server. I think the 64bit IDE design time connection is the way to go......

Belated reply, but pasfmt integrates with the IDE and tracks/retains bookmarks across formats.

According to @TBx, the attack appears to be vectored towards DOSing the Apache server, more than it is about the forum software.

V16.0.10.85 Fix: accept single line literal starting with three quotes Show invisible Source Indexer when searching is invoked Don’t auto-dock Floating Explorer when invoked from menu Locate Editor Position Do rename when leaving Entity Insight name edit with changed content Option to hide units from VCL/FMX framework in Use units Parser recognizes new generic constraints interface and unmanaged. Support multi-select with Break up Property and Convert Property to Field Download from MMX Beta Setup

Hi All, I just ran the Sempare Template Engine (https://github.com/sempare/sempare-delphi-template-engine) through Deep Wiki (http://deepwiki.com/) I was quite impressed with the documentation it created. https://deepwiki.com/sempare/sempare-delphi-template-engine It analysed the code and I think does a good job describing the internals from parsing, evaluation to documenting the helper functions. I think this can be really useful for other projects too. Anyways, just a reminder - please star the project on github and a bonus, support with a 'commercial support'.

We don't recommend relying on this says everything we need to know

I have just released a GExperts beta version for the 64 bit IDE. Read the blog post for details.

With each new edition you have a higher and higher number of features. They are never* removed. But for bugs, math always stays on zero: TheNumberOfBugsFixed - NewIntroducedBugs = 0. 🙂

This public repository: JavierusTk/VSCode-Switcher: Tool to edit Delphi files simultaneously between Delphi IDE and Windsurf, so it allows to take advantage of the AI tab completion is 100% coded with Claude Code; the documentation is made with Claude.ai (the chatbot), except the files README.md and CLAUDE.md, that were made by Claude Code itself It's a small tool to allow you take advantage of Windsurf "TAB-coding". It's amazing how much it helps with boilerplate-kind code

Adding the _LocationEssentials framework to iOS 26 and iOS Simulator 26 SDK fixed the problem and I was able to compile my test projects with Delphi 12 Athens and Delphi 13 Florence. https://developpeur-pascal.fr/ios-26-reclame-le-framework-_locationessentials.html

That's not quite true. They will usually allow you to continue your subscription if it run out not too long ago. But of course starting with the date it run out. Also, there are some special offers from time to time, where you can save part of the price for a new license. But for a while keeping the subscription active has been the cheapest way to update (if you can call that "cheap"). And every time you have to remove "platinum support" from the order. The one thing that has annoyed me the most, is that you need an active subscription to even download an install bugfixes.

Programming with AI Assistance Introduction I’ll take a few minutes to explore the current relationship between AI and programming, as of March 4, 2025. AI evolves so rapidly that claims need constant reassessment. A year ago, I argued AIs relied solely on their knowledge base, not internet searches—a point now outdated, as they do both. So, let’s dive into the key question: Can AI fully replace a programmer today or soon? Can AI Replace Programmers? The short answer is no, and here’s why. Claiming AI can replace a programmer assumes it can flawlessly interpret a designer’s or user’s instructions without ambiguity, generate error-free code, and fix mistakes after the fact. It also implies the AI can review and adapt existing code to meet new or corrected requirements as an application evolves. Picture a dialogue with an AI to build a program. It could stretch over days or weeks, requiring constant backtracking to resolve misunderstandings. Each revision would alter the program, spawning fresh errors—something programmers know all too well. Iterations might edge us closer to the goal, but sifting through endless chat logs to spot where communication faltered would be exhausting. Now, suppose we had a tool tailored for this AI interaction, resembling an IDE (Integrated Development Environment). It could let us search and document requirements, track how new ones affect old ones, and perhaps include a UML generator. Sounds helpful, right? Maybe not—it’d likely just pile another layer of complexity onto development, one still reliant on skilled programmers or analysts to feed it. Even if we fed this knowledge into an AI, it’d need deep familiarity with IDEs or command-line tools to produce the final program. More critically, someone must verify the output meets requirements and works—not just compiles cleanly. Maintenance adds further hurdles: when users report issues in production, do we tweak the original requirements and regenerate the code, or prompt the AI to patch its own prior work? It’s a tangled mess, don’t you agree? Those videos touting “code an app with AI, no skills needed” are like ads promising “speak English like a native.” It’s a hollow pitch—you won’t master it without the foundation, though exposure might sharpen your skills. AI as a Programmer’s Ally So, are those videos about coding with AI useful? No. Their makers aim to entertain you (and rake in ad revenue) while flexing their cleverness—not to teach you AI mastery. Their business would dry up if they did. But here’s a better question: Can AI boost a programmer’s performance? Absolutely, without a doubt. Practical AI Techniques AI won’t replace us—it empowers us. Here’s how I use it daily: Setup: I keep profiles on key AIs—Grok, GPT, DeepSeek, Mistral—ready in browser tabs that auto-open. Even if I rarely touch the last two, they’re there when needed. Function Generation: For standalone functions with clear inputs and outputs, I ask the AI to draft them. Early results may not compile, but they give me a head start. With practice, I’ve honed prompts to get working, compilable code on the first go. Bug Hunting: When my code has a sneaky bug, I pass it to the AI with a description of the unwanted behavior. It often pinpoints the fix. HTML Cleanup: Hand-edited HTML can turn into a cryptic mess. When it’s unreadable, I hand it to the AI to refine and flag errors—a real time-saver. Instant Help: The F1 key once gave contextual IDE help; now I ask the AI for explanations on terms, classes, or functions. It delivers detailed answers and examples, often tailored to my project if we’ve been chatting. Documentation: Most coders dread documenting modules, yet it’s vital for maintenance—the costliest phase of software life. I task the AI with it, specifying depth and skipping obvious lines or pseudocode comments. Performance Tweaks: Facing a bottleneck? The AI can estimate runtimes from source code alone and suggest optimizations—no execution needed. Unit Tests: Tedious, repetitive unit tests are perfect for AI. Give it a controller interface, and it churns out tests fast, ensuring reliability even after changes or integrations. REST Integration: Beyond chat, I’ve built REST interfaces in my programs to query the AI directly with precise prompts, embedding its responses into the app. For example, I use a Stub program to generate varied test data (e.g., JSON arrays of names, split by nationality or location) instead of relying on monotonous random lists. It’s efficient and spares me manual coding. Mastering these techniques—especially REST-driven data generation—lets you apply AI creatively in client projects. The possibilities far exceed this article’s scope, but paired with the next approach, they’ll transform you into a sharper developer. Beyond the Technical: Prospective Thinking AI shines beyond pure coding tasks in what I call "prospective interactions." Before starting a project, I weigh my options—techniques, code structure—and consult the AI. I list my alternatives, and it reasons through the best path, explaining why. I don’t always follow it, but it clarifies my choices. Better yet, I’ll ask it for fresh angles I hadn’t considered. That’s when coding becomes exhilarating—you shift from a technical grinder to a creative problem-solver. That’s the real power of AI as a programming partner.

Meaning, the server sends something to a client that it did not explicitly ask for. Such as a notification when another client connects/disconnects, or when a client sends a message to other client. Things which can happen at any time, outside of the normal request/response flow of "I want something" -> "Here you go" (solicited). "Oh, BTW, here is something else I have for you but you didn't ask for" (unsolicited). That contains a mix of solicited and unsolicited messaging. The new client connects, gets a greeting, says hello, and gets acknowledged. The client initiated an action and got a direct response before doing anything else. That is solicited messaging. Then, all of the other clients get notified of the new connection. They didn't have to send any requests to receive that event, they are just blindly told that it happened, when it happened. It happened in the background, and they have to passively watch out for it. That is unsolicited messaging. That is unsolicited messaging. Client1 sends a request to the server (solicited), but then the server notifies Client2/etc (unsolicited). Client2/etc did not send a request to receive that event, it/they are blindly told when the event happens. Same thing. All that extra messaging that the server does in the background needs to be handled properly. But if you code your server to just receive a request and send a response, you won't be able to handle that extra messaging at all. And right there is the problem. The code you showed doesn't handle that last part. You can't just write to a given client connection whenever and from wherever you want. You have to serialize your outgoing messaging. Think of what would happen if 2 clients happen to connect/disconnect at the same moment and thus need to notify the same target client. Or if multiple clients send private messages to the same target client at the same moment. You don't want multiple messages to that target client to overlap, that will corrupt your socket communications. So, you must provide some mechanism to make sure that subsequent messages wait their turn while an earlier message is still being written to the socket. That could as simple as putting a critical section or other exclusive lock around socket writes. But, that can cause unwanted blockages in threads that want to write to a socket, so that is where my earlier suggestion to use a per-client queue comes into play instead. That way, only the thread that actually writes the queue to the socket may block, while other threads are free to continue putting new messages into the queue. Well, that is certainly true, if you do the writing in the OnExecute event (as you usually should). But, if OnExecute never writes, only reads, then you can do the writing from another thread. I didn't say anything about a delay.

As for thousands of warnings ... Clean that mess up. Warnings and even hints can relate to significant problems in the code. If you have thousands that are "uninteresting", they still can drown out those that are really vital.