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

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

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......

The problem with bookmarks and breakpoints is that they are bound either to the current project group or the current project (with a fake group), whatever is opened. Any attempt to keep those during formatting will most likely still damage any of the others. F.i.: Assume unit X is used in several projects. Formatting unit X while project A is open may keep the breakpoints, but the breakpoints saved in project B may not match anymore when opened.

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

I actually don't mind on-topic advertisements that much. After all, it's no different than 3rd party vendors announcing their libraries and not really participating beyond that. We got a couple of those already *cough* TMS *cough*. What I do mind is the dishonesty of pretending to discuss a topic but actually only drive traffic to their site in order to harvest leads. It's trolling. I agree that the topic was interesting, and I actually started to write a reply describing our own experiences and solutions, but then I noticed that neither the post nor the page that it links to actually contain any useful information; It's just a long collection of keywords and the whole message can be accurately summarized as "updating code can be problematic". It doesn't contain any actual solutions and some of the things that it says are just plain nonsense. The other "articles" posted here and on their site are just more of the same: Here are some words, and now enter your name and email to get access to an article with more information on this topic that we just failed to say anything useful about. Wow! F*ck 'em. I think we should. We don't allow spam and this is spam - even if it pretends to be something else.

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.