Leaderboard

Hi everyone, more than twenty-one years ago, I started the German-language part of this forum and could not even begin to imagine what it would become. Thanks to the tireless support of many moderators as well as your thirst for knowledge and willingness to answer other people's questions, it has become a pillar of the virtual Delphi community - even far beyond the German-speaking world. Since 2018, this English-language part of the forum has also been available, with considerable support from Lars. With an online presence of this size comes the obligation to take proper care of it. I have always been very happy to do this, but over twenty-one years is a very long time and life and its priorities change. I can't help but realize that my daily/weekly time has become less available and the time has come for me to hand over the management of the forum to someone else. Thankfully, Thomas B. ("TBx") has agreed to take over the Delphi-PRAXiS and continue it in good hands - together with Lars, of course. You know Thomas as a longtime moderator of this forum and now he will take over my previous role. I myself will of course remain part of the Delphi community - not least because I continue to work a lot with Delphi in my job. I will also remain a part of this forum. Thank you all for over 21 great years!

I don't need any new features. I just need that the existing features work as intended. And there are many areas where existing features need to be made usable again (e.g. refactoring, code formatting, HighDPI). OK, one new feature would be nice: compiling for Raspberry Pi. But fixing the existing features needs to be done first.

Niklaus Wirth just turned over in his grave about this proposal.

Personally, I see no reason to add more options to obfuscate my code. I can do well enough with goto and with when I need to scratch that itch. And when I really want to spice things up, there is always absolute.

The only self explanatory code is the trivial one. In other situations there is no such thing as self explanatory code, especially if it also needs to be performant and thread-safe. I have written tons of self explanatory code, for which now I don't know what was I smoking at the time. Sometimes, after a lot of digging I can remember why it was written like that and why it should stay that way, but mostly no. So I am not sure if it was just crappy code from the times I didn't know better, or there are valid reasons behind the awkward design choices.

https://firebirdsql.org/en/firebird-5-0/ New In Firebird 5.0 Summary of New Features Firebird 5.0 introduces many improvements without any changes in architecture or operation, the most important are: Parallel (multi-threaded) operation for backup/restore, sweep and index creation; Partial indices; SKIP LOCKED clause for SELECT WITH LOCK, UPDATE and DELETE statements; Inline minor ODS upgrade; Compiled statement cache; PSQL and SQL profiler; Support for WHEN NOT MATCHED BY SOURCE for MERGE statement; Support multiple rows for DML RETURNING; New built-in functions and packages; Denser record-level compression; Network support for scrollable cursors;

Today, almost all computer security relies on asymmetric cryptography and X.509 certificates as file or hardware modules. And the RSA algorithm is still used to sign the vast majority of those certificates. Even if there are better options (like ECC-256), RSA-2048 seems the actual standard, at least still allowed for a few years. So we added pure pascal RSA cryptography and X.509 certificates support in mORMot 2. Last but not least, we also added Hardware Security Modules support via the PKCS#11 standard. Until now, we were mostly relying on OpenSSL, but a native embedded solution would be smaller in code size, better for reducing dependencies, and easier to work with (especially for HSM). The main idea is to offer only safe algorithms and methods, so that you can write reliable software, even if you are no cryptographic expert. 😉 More information in our blog article about this almost unique features set in Delphi (and FPC): https://blog.synopse.info/?post/2023/12/09/Native-X.509-and-RSA-Support

I have just built an installer for GExperts 1.3.24 Beta1 for Delphi 12. Note the word “Beta” in the release name! We are one step up from Alpha, there are still many bugs, but overall it seems to be stable. Most of the bugs manifest themselves as display glitches on high DPI monitors. Continue reading in the blog post

Nonsense. Windows developers have been able to create professionally looking applications that for decades without the aid of layout controls. The main reason for amateurish looking applications is amateurish developers. The DevExpress layout control is tightly coupled to the rest of their library but even if it had been possible to separate it from the rest then it would be a terrible idea. Embarcadero does not have the resources or expertise to maintain and evolve something as complex as TdxLayoutControl. Just look at the state of the 3rd party libraries they already have incorporated into Delphi. I wouldn't mind a rudimentary layout control as a part of the VCL but if they can't even get something as simple as TGridPanel to work properly then I think it's better they not even try.

Please note: Only the 12.0 Athens GetIt server has been restored at this point in time (Feb. 7th). https://blogs.embarcadero.com/getit-update-additional-rad-studio-12-getit-packages-are-now-available/ https://blogs.embarcadero.com/rad-studio-12-athens-patch-1-available/ List of QP issues addressed in the patch: RSP-44063 Bug in MOD operation for Win64 Release configuration RSP-43656 [REGRESSION] Wrong codegen when passing empty open array to operator overload RSP-43568 Issue with TURI.Query Changed adding an equal sign to the URL ends with ?WSDL RSP-43551 When MDI form & Custom Styles are used together, the Process cannot be terminated. RSP-43547 New VisualManager feature causes crash in TCustomForm.WndProc() with Action=caFree RSP-43515 No event OnCameraDidFinishTaking for TTakePhotoFromCameraAction RSP-43494 Event OnValidate fails when the DBGrid is full - AGAIN! RSP-43463 JSON serialization error with scientific double notation RSP-43459 TEdit.FilterChar crash app on Android RSP-43422 NetHttpClient parsing URL parameters is incorrect RSP-43418 Wrong Delphi code optimization for integer div/mod RSP-43407 The Delphi compiler in RAD Studio 12 is no longer able to resolve standard types by their aliases when generates HPP files for a BPL package with components if the referenced types are declared in other units RSP-43383 Delphi 12 Android TEdit error RSP-43362 [iOS] TListView set search visible to True, the system will crash when clicking into the search area. RSP-43326 Blob reading is broken for 64-bit platforms in dbExpress RSP-43318 Incorrect ShortCut in TActionList RSP-43311 TSQLTimeStampOffset problems with Firebird 4 RSP-43299 TFlowLayout exception when all its elements are set to invisible RSP-43274 Arithmetic operations on record fields return incorrect results in certain cases if the "Optimization" compiler option is enabled RSP-43235 Structure view and Search for a method box no longer populated RSP-43007 Internal compiler error F2084 RSP-42860 FMX TListBox List Index Out OF Bounds RSP-42692 Ctrl-j - invoke template don’t work RSP-42682 TreeView crash RSP-42657 TTreeview crashes when scrolling in iOS RSP-42634 QBE component causes fatal IDE crash when removed from form RSP-42616 FMX: Key Handling different behavior in Delphi 12 RSP-42601 TURI with encoded Params are mangled when initialized

Since years, our Open Source mORMot framework offers several ways to work with any kind of runtime arrays/objects documents defined, e.g. via JSON, with a lot of features, and very high performance. Our TDocVariant custom variant type is a powerful way of working with such schema-less data, but it was found confusing by some users. So we developed a new set of interface definitions around it, to ease its usage, without sacrificing its power. We modelized them around Python Lists and Dictionaries, which is proven ground - with some extensions of course. Two one-liners may show how our mORMot library is quite unique in the forest/jungle of JSON libraries for Delphi (and FPC): +] assert(DocList('[{ab:1,cd:{ef:"two"}}]')[0].cd.ef = 'two'); assert(DocList('[{ab:1,cd:{ef:"two"}}]').First('ab<>0').cd.ef = 'two'); Yes, this code compiles and run on Delphi - even the antique Delphi 7. 😆 If you compare e.g. to how the standard JSON library works in the RTL, with all its per-node classes, you may find quite a difference! And there is no secret in regard to performance, that our JSON processing is fast. More info: https://blog.synopse.info/?post/2024/02/01/Easy-JSON-with-Delphi-and-FPC

Straight Outta ChatGPT

it will also be enough if QP is operational by the time D13 arrives

Bug fixes, bug fixes and after that: more bug fixes. Don't release until there are no more unresolved bug reports. Quit following hypes just for the hypes sake.

I have created a unit, that is similar to String Interpolation. Of course real Interpolation would be a compiler feature. TStr('Hello, {0}! Today is {1:ddd}, it's {1:HH:mm} now.').Params(name, date); // Hello, Mark! Today is Wednesday, it's 19:40 now. Variables where automaticly detected and converted (automatic type inferrence via Generics), so no need for IntToStr, FloatToStrF... Here a short Description of the Format. It is similar to the Format Specifier of .Net. The Date Format is almost the same like in Delphi, but the other Specifier are different. but i think its a way better than the sprintf Convention that Delphi uses: Integer and Float where automaticly converted and formatted as needed: C for Currency (Number for Decimal Places) D for Integer (Number for prefixed Zeros) F for Double (Number for Decimal Places) Date can formatted with: dd = Day, MM=Month, yyyy=Year HH=Hour, mm=Minute, ss=Seconds there are further possibilities in the readme Readme: https://github.com/VoSs2o0o/NetFormat/blob/master/readme.md Code: https://github.com/VoSs2o0o/NetFormat/ Download: https://github.com/VoSs2o0o/NetFormat/releases Website in German with descriptive Content about the Code: https://www.cloud-9.de/entwicklung/delphi-besserer-format-befehl

Neat: https://www.idera.com/ppc/uptime-infrastructure-monitor/it-performance-monitoring

Maybe if they just built the web servers with Delphi and use the Delphi philosophy, they'd work

I have a client who wants to use DWScript to do structural load analysis of large models (thousands to millions of nodes). Since DWScript compiles to an AST (Abstract Syntax Tree) and then executes the objects in that tree, he was a bit concerned about performance. He had tried various other scripting systems and they were just too slow. So we did some benchmarking of a sequence of typical calculations in Delphi vs DWScript. As expected the Delphi compiled code was about 4 times faster than DWScript. The client thought that that was acceptable but I decided to try out the DWScript jitter anyway... As it turns out there might just be something to David's complaints about Delphi's math performance 😉 because with the jitter enabled DWScript was now more than twice as fast as the native Delphi code. Also, Delphi 64-bit was about 25% slower than 32-bit and 64-bit "optimized" was slower than "unoptimized". Not to take anything away from Eric Grange's amazing work on DWScript, but I would be embarrassed if my native code compiler was outperformed by a scripting system.

Thanks to Ethea S.r.l. who commissioned Luca Minuti to write a Delphi implementation of SAML protocols/libraries and make it available Open-Source to the entire Delphi community. The project has now been completed also for the 64-bit platform as well. The project is available on Git-Hub at this address: https://github.com/EtheaDev/Delphi-SAML

Sounds like it were a religion...

I wasn't going to bring it up in this thread.. but since you opened the door... I've been working on one for a while now https://delphi.dev - but it's a big project for one person and I have a business to run and a family. Docs - https://docs.delphi.dev/ Source https://github.com/DelphiPackageManager Installer - https://github.com/DelphiPackageManager/DPM/releases (codesigned by VSoft Technologies Pty Ltd). It is working well, but I have yet to implement loading design time packages - the reason for that is a lack of spare time. I did redo the IDE user interface a while back and that part is much easier to use than before (modelled on Jetbrain's Rider nuget support) - I use it daily. DPM supports Delphi XE2 - 12.0 - which should make upgrading to newer delphi versions easy - if the packages you use are available for the newer version of delphi, just open your project in that new version (with dpm installed) and dpm will automatically download and install the packages required for the project (and update search paths accordingly). Packages can be hosted by a package server, or a directory (ie network file share). The website is also a package server - that part is working well, however the ui needs a lot more work so that users can create api keys for pubishing packages. Right now the only packages there are ones I forked and published. The website is an asp.net 8.0 application (because I have a lot of experience with it) with a react front end, using a postgresql db - running on ubuntu server on a vm on one of my servers in Sydney - not ideal for latency for the rest of the world - it is behind cloudfare but api routes are excluded (cloudfare does help as a cdn for the images and javascript). If interest in/usage of the server actually took off I would move it to a cloud host in the US to improve latency (that would require some funding). The actual package files are on a cdn (bunny.net) and are regionally cached, so once someone near you has downloaded a package it is cached on their edge and its fast to download. Right now that's not costing me much but if usage ramps up it would. I went with bunny.net purely because of pricing - but apart from the stupid name it's actually a pretty good service. Recently someone (thanks @Geoffrey Smith ) contributed a tool for creating dpm package definition files (json) and we have been working on that together (it's installed by default now). Geoff created this tool to ease creating package definitions for some commercial libraires he is using. I would love to see more interest in the project and welcome contributions.

Due to the supply chain disturbances, we had a 5 month delivery wait for servers and parts for a while, so I can relate to delays. The problems here are: - Lack of proper communication. "No news. Next update at ..." is better than silence! - Insufficient contingency planning? - Insufficient backup and recovery plans? - No plan B? There are many capable cloud hosting services that doesn't take forever to spin up a pack of servers. The cost might be high, sure - but so is the cost of losing the trust of your customers.

Did you know that LEGO and Michelin are competitors? They both manufacture tires...

I don't know what to think after reading that article. Here are my comments on it: - the classic way of truncating the last 2 digits with div and mod 10 (or 100) does not involve a costly div or mod instruction on modern compilers (*cough* even Delphi 12 now does it - apart from the bugs that came with it) - I think C++ compilers would detect doing a div and a mod instruction and the code they emit would be further optimized so it does not require the "workaround" that the Delphi RTL uses by calculating the modulo by subtracting the div result times 100 from the original value. - the pseudo-code he shows for detecting the number of digits is correct but this is never what gets executed - and you either rewrite this into a few branches (as you can see in the RTL), a C++ compiler might unroll the loop or some other trickery is applied The DivBy100 function was introduced by me in RSP-36119 and I already notified them that DivBy100 can be removed in 12 because now it properly optimizes a div by 100 - however, that affects performance only by like 0.5% or so. As David correctly pointed out the real bottleneck is the heap allocation - and not only a single one when you just turn an integer into a string and display that one but when you concat strings and numbers the "classic" way because then it produces a ton of small temporary strings. That issue even exists when using TStringBuilder where one might think that this was built for optimization. If you look into some overloads of Append you will see that it naively calls into IntToStr and passes that down to the overload that takes string. This is completely insane as the conversion should be done directly in place into the internal buffer that TStringBuilder already uses instead of creating a temporary string, convert the integer into that one, pass that to Append to copy its content into the buffer. This will likely be my next contribution as part of my "Better RTL" series of JIRA entries.

I don't care that much about the IDE. It's the compiler and the language that matters more to me.