Lazarus Release 4.0

I think unfortunately what holds Lazarus back is the Pascal programming language. Although it is a very capable language that can hold its own against other languages, it suffers from a reputation of being obsolete.

It’s a pity that the C family of languages won out over Wirth’s languages. Pascal’s superior string handling alone would have saved us from countless security flaws.

As I understand, the main problem with native web views is that you now have to deal with all the inconsistencies of e.g. Blink vs WebKit. Also, browsers tend to be more aggressively updated, which translates to potential app breakage due to bugs or deprecated features.

With respect to Lazarus, I agree that the ecosystem around it is not exactly great. It would be interesting to see LCL ported to something more modern that is reasonably simple, cross-platform and has good tooling. E.g. Go, much as I dislike it as a language, would probably be a great fit for something like that. And Pascal being fairly conservative and easy enough to parse, I suspect you could even automate this translation for the most part.

Why doesn't the linker strip out unused code?

I think Go will do it, but I indeed enjoy Free Pascal for this as well. It's also nearly trivial to set up cross compilation using FPCUpDeluxe, so I've shipped applications to clients on Windows when I do all development and compiling on GNU/Linux.

.NET can create self-contained executables pretty easily (via _dotnet publish_), both including the required framework assemblies and without them. But they'll still be comparatively large.

> What are my options?

> I stick with Qt

These come up on search results if you combine Qt plus the language.

Go:

* https://github.com/mappu/miqt

Java:

* https://github.com/OmixVisualization/qtjambi

Nim:

* https://github.com/jerous86/nimqt

* https://github.com/seaqt/nim-seaqt

Zig:

* https://github.com/rcalixte/libqt6zig

https://areweguiyet.com/

Also did you test similar functionality in C++, I haven’t compared many implementations but I app I use that has an SQlite db being read with Qt(C++) is pretty sluggish whenever you touch the DB.

Maybe store the values in a dict and only read/write from sqlite when needed. Dicts are very fast in python.

> I could use C++ and stick with Qt, but I'd much prefer Rust. Rust has no good Qt bindings. What are my options?

There are several Qt binding for rust, for example cxx-qt. I haven't tried myself but it looks maintained. Why is it not good?

Otherwise, the most promising equivalent to Qt in Rust would be Slint.

Is Cython and/or avoiding copies an option?

Java perhaps? That was one of the core promises of the Java ecosystem.

Definately remember it fondly - and Jeff Duntemann who continues to update and publish his definitive works on learning assembly - the latest edition/revision is: "x64 Assembly Language Step by Step" - https://www.contrapositivediary.com/?page_id=5070

Vividly!

In particular, his tech e-mail announcement/newsletter was where I first learned of a small startup w/ the unlikely name of "Google".

It was the common complaint about writing VCL apps in Delphi - that single message box app would be 0.5MB binary.

But that was the static overhead of VCL core library and the benefits were considerable compared to writing raw WinAPI.

And unlike MSVC 16kB WinAPI executable you didn't have chance of sudden surprise "oh, but you need to update msvcrt.dll to run this" because Delphi (and Lazarus/FPC) default to statically linking the runtime

That's indeed a statically linked binary. Release, with smart linking (so only things that are actually used are linked; otherwise it'd be ~20 Mb), debug symbols stripped. Measuring .exe size when linking dynamically would kinda defeat the purpose of the experiment, since you'd still need to distribute the DLLs to the users for any real world app.

The wiki is full of incomplete, obsolete, or otherwise not-so-useful articles. It suffers from typical "wiki as documentation" efforts, where instead of concentrated efforts from domain experts, you get a thousand half-baked opinions.

It has good stuff, but I'd wager the "bad stuff" outweighs it by a large margin.

Thank you for your response and your example.

The problem is optics. Pretend I'm a brand new user and I want to build GUI applications. I've heard of a language called Freepascal and of an IDE called Lazarus. I think they're connected but I don't know how. And what's Delphi?

Where do I start?

? Welcome to the Free Pascal and Lazarus Wiki [2] https://wiki.lazarus.freepascal.org/

? Lazarus Documentation https://wiki.freepascal.org/Lazarus_Documentation

? Welcome to the Free Pascal and Lazarus Wiki [1] https://wiki.freepascal.org/

? https://www.lazarus-ide.org/

Most IDEs and languages have a Documentation link. Which link do I use to start with?

FreePascal has lazarus docs and Lazarus has FreePascal docs?

As a new user I can slog through 4 different links of schtuff, I guess. (Disappointment and frustration lie ahead; broken old buggy software that doesn't match the documentation. New User doesn't know that yet.) Maybe I'll just look for Youtube videos, but my enthusiasm is draining.

I'm used to this:

https://go.dev/doc/ Everything linked from go.dev/doc works today and it's coherent. Everything.

As other responses mention, the docs as a rule are out of date and confusing.

[1] btw redirects to [2] from search engines.

The only relevant part I can find from that article is:

> One criticism we've seen of the FreePascal project in general concerns its documentation, although there is quite a lot of it: eight FPC manuals, and lengthy Lazarus docs in multiple languages. There is a paid-for tutorial e-book available, too.

The criticism is that there is too much documentation available? And they're long, and dare even to be available in multiple languages?

Interesting, which AI system are you using?

This doesn't match my own experiences, I've tried a few times to ask about Pascal and the results have always been appallingly bad. From nonsensical syntax (sometimes mixing in C-style syntax), to made up unit and object names, I'm surprised if it can even manage a correct "hello, world".

By comparison, Python generation can be pretty decent (not that it can't run into the same issues, but it is less frequent). I always assume it's because Pascal's online presence is gravely reduced compared to other languages. It is still a fairly popular language, but I'd wager most Pascal written is not published online.

Lazarus is available on Linux too, and on some other platforms as well, is what I've read on its site.

ALGOL-60 was huge, in around 1960. Niklaus Wirth had a detailed proposal for the next version of ALGOL, to be called ALGOL-X.

The ALGOL committee rejected it, choosing a competing and much more complex language headed by Adriaan van Wijngaarden. This became ALGOL-68 -- and killed ALGOL.

Wirth took what was known as ALGOL-W and turned it into Pascal.

FWIW I wrote about this:

https://www.theregister.com/2024/01/04/niklaus_wirth_obituar...

https://www.theregister.com/2025/01/07/algol_68_comes_to_gcc...

Another offshoot of Algol-60 was CPL, intended to be more general-purpose and capable. But it was big and hard work to get it working.

So Martin Richards designed, a simpler intermediate version, BCPL. (He also built an OS in it, TRIPOS. This formed part of AmigaOS 1.x.)

BCPL was further stripped down to B, and then evolved into C.

This is one of the best introductions to what programming a computer is about that I know. I highly recommend checking it out, even if Pascal-like languages are not your cup of tea.

I'll often use `result` as the return value in other languages, largely because I learned it in Delphi 25 years ago. It doesn't have the automatic return value semantics elsewhere, so you also need `return result` or whatever, but it's crystal clear what the intent is. I prefer it for that reason alone.

`Result` is clearer given that in Pascal, a function name by itself in any other context is a function invocation (with no arguments). That is, you then have this kind of stuff:

  type PInteger = ^Integer;
  var X: Integer;

  function Foo: PInteger;
  begin
    Foo := @X;
    Foo^ := 123;
  end; 

> I'm torn about which is clearer, that magic variable style or assigning to the function name as one does in VBScript.

That's also "old style" Pascal, and still supported by Free Pascal (even though the compiler gives you a warning for doing it!).

>I also have mixed feelings about golang's `func Doit() (result int, err error)` syntax. To quote another platform, "there should be one, and preferably only one, obvious way to do it"

Isn't it basically equivalent to an anonymous tuple which is automatically deconstructed on assignment?

For glance reading code, a predictable variable name or return keyword is a lot easier imo.

Yeah, technically you could add text with the link submission, but it will demote the link somewhat and I guess is just frowned upon here.

Oh it seems my point was ambiguous, I really meant the website should include it

Since I read about the guy who was surprised that anything other than SPAs exist (the full page reload magic incident), I realized there are way younger people in the field with no context or knowledge of CS history whatsoever, so some of them not knowing about Lazarus or Delphi sounds totally plausible.

You forget that every day, someone wakes up who is new to this planet.

I have also met people who have to ask what Lisp is. You might be surprised at how many people don't know things like this.

I know Delphi, yet I didn't know Lazarus until now. I'm sure there are others like me.

I can understand not wanting to explain Delphi, but come on, not everyone knows the name of every IDE for every language. It doesn't hurt to add one sentence explaining that. If I hadn't seen the comment above, I wouldn't be able to consider Lazarus in the future if I ever use Delphi again.

10000 thousand people a day hear about any given topic for the first time in their life https://xkcd.com/1053/

> Delphi and Lazarus have been around for decades. It's like asking what lisp is.

No.

Everyone thinks their pet project is obvious and self-explanatory.

This is NEVER EVER a safe assumption. Remember that our entire industry is a mysterious black box to the outside world.

I worked for A Prominent North American Linux Vendor for a while. I was hired to work on the docs for one of their projects.

I'm an industry veteran with at that time over 25 years of broad cross-platform tech experience from CP/M to Linux to mainframes.

It took me a month of hard digging to get an extremely vague overall concept of what the product was and did.

Most of the company had no idea -- it's not Linux-related in any way -- and many of them regard the entire product platform as an evil to be expunged.

This is typical for that vendor. Aside from their Linux distro, ask for a tweet-length summary of any of their portfolio, expressed in general terms not specific to that product or vague marketing-ware, and nobody in the company can give it.

Nonetheless they are a multi-billion-dollar vendor.

But they only sell into established markets.

Uh... there are new people every day... about 10,000 of them:

https://xkcd.com/1053/

Because these things get shared elsewhere and end up getting looked at by someone who has no idea what the product is, like me, this time, with Lazarus.

Yes, this is what I get when using those installers.