Rendered at 12:20:14 GMT+0000 (Coordinated Universal Time) with Vercel.
ziotom78 23 hours ago [-]
Initially, I was skeptical and thought that this is the millionth vibe-coded project that will die once the author gets bored.
However, when I checked who the author is, I found he is is Graeme Geldenhuys, the author of the fpGUI library [1]. He surely has a lot of experience with FreePascal and the Pascal language, and in these years he has proven to be a committed worker (fpGUI exists since 2010!). So, this project seems to start on good grounds!
I really hope it will gain traction, as I have often wondered myself why somebody would not create a “clean” Pascal compiler from scratch with no legacy cruft and good defaults (e.g., UTF-8 strings, inline variable declaration).
Which has had a strange relationship with Delphi, for a while they were responsible for Delphi.NET.
samuell 1 days ago [-]
It is a bit curious with the Mojo 1.0 beta coincidence, as Pascal was the other langauge with a highly readable and quite simple language combined with performant compiled code without GC.
What it lacked was a modern compiler and stack. There is FreePascal for sure, and Lazarus is impressive, but it for sure has its baggage.
vintagedave 1 days ago [-]
Yeah, Python and Pascal have always felt like they share similar vibes, despite being massively different languages. (Ease of writing, ease of reading, good inbuilts, etc.) Mojo feels like a clean take on similar goals... it's essentially a cleaner Python.
jibal 24 hours ago [-]
Mojo is faster than Python but certainly not cleaner.
vintagedave 24 hours ago [-]
Can you share more? I haven't actually used Mojo, I've just read about it, so I'm going on vibes (not AI ones :D) here. I'd love to hear your opinion.
magicalhippo 1 days ago [-]
Looks interesting. As someone who's been using Pascal since Turbo Pascal 6, and use Delphi daily at work, I'm not sure I quite get the "COM-style interface GUID" objection. What exactly about it is complex, and how do you implement Supports() without it?
jasim 1 days ago [-]
In my early programming days, working with Clipper, I used to look at Delphi from a distance with awe and a bit of jealousy. There also used to be PowerBuilder and Paradox, as competition to the xBase platforms.
I'd love to hear more about how you're using Delphi and what it excels at, compared to current web and native software stacks.
vintagedave 1 days ago [-]
Not the OP, but I can answer with an objection to COM-style GUIDs myself. Delphi's interfaces are heavily based around COM, and so you need GUIDs, ARC, etc.
But interfaces as a concept don't require the COM backend. If you want your code to be cleanly separated, but don't want to split ownership/management models* (create/free vs ARC), and have no need for an interface and type identity to be managed outside your code and process (ie no COM), then interfaces that are not tied to ARC, and not tied to COM, give the clean code benefit without the baggage.
[*] People work around this by implementing interfaces from a base class with no-op AddRef/Release methods. But this kinda shows the problem: why is that necessary?
I work with Oxygene which is another modern Pascal -- quite a few new Pascals have popped up recently, I get the sense there's a real desire for something new! Our interfaces can be 'clean' and we support soft interfaces, too.
magicalhippo 1 days ago [-]
But you don't need to specify a GUID for an interface in Delphi, and Blaise uses ARC for both objects and interfaces.
vintagedave 1 days ago [-]
True! But here at least Blaise is consistent. It’s not mixing models.
My real wish for Pascal interfaces is that they are pure. Some of that is not bringing in COM stuff (including recounting) because I think memory management is or should be different to interface-based clean coding. Another: In Delphi if you define a property in an interface, you have to bring in the getter and setter too. And that makes them implicitly public / visible (even if the implementing class declares them as private.) And they must be methods, there’s no way to say “read, but I don’t care how” (where Delphi can normally read fields too.) In other words, the semantic of “I want a property with read access” causes the interface contract to define the implementation, including making public the normally private / internal backing.
Whereas what I really want is to declare “property Foo: Integer read;” and the interface requires that is satisfied, but not how. In other words, interfaces are pure - they don’t bring in extra baggage. You can do that in Oxygene.
magicalhippo 1 days ago [-]
Being restricted to COM-style interfaces, so no true properties like you say, that I totally get.
However my question was mostly with the objection against having a GUID, and how Supports() is solved without said GUID, especially since Delphi interfaces doesn't require a GUID in the first place.
vintagedave 1 days ago [-]
I guess the language implementer needs to answer how they implement Supports :)
But within one app, ie not crossing boundaries, perhaps their object model's vtable carries references to the interfaces, so casting of any sort to/from object-interface and interface-to-interface would work, including Supports?
dvh 1 days ago [-]
For me the only reason to use pascal is GUI apps but this doesn't have it.
jasperry 23 hours ago [-]
Excited to see another project targeting the QBE back end, from what I can tell it's a great lightweight alternative to LLVM.
graemeg 23 hours ago [-]
Yes it has been fantastic to work with QBE so far. It's way simpler than LLVM, giving you about 70% of the LLVM performance, for 10% of the effort. :)
Only downside is Windows support.
paddim8 18 hours ago [-]
Unfortunately the QBE code is really strange so if you need to make some changes yourself it probably won't be very fun
crq-yml 14 hours ago [-]
I'm actually really happy to see a fresh "just Pascal", and one that is aiming for a slim bootstrap at that.
mark_l_watson 22 hours ago [-]
That looks cool. If they support binary releases on macOS Apple Silicon I will try it out.
I wrote one major project in UCSD Pascal on Apple II 45 years ago: my Honnibo Warrior Go Playing program. For its time, a fantastic dev environment.
superdisk 1 days ago [-]
Looks cool and does aim to address some of the annoying warts in Pascal. Especially the memory model.
HexDecOctBin 1 days ago [-]
Does this support declaring variables anywhere (as opposed to only in the beginning of a function)? That was my primary complaint when using Lazarus.
pjmlp 1 days ago [-]
Delphi has allowed this for quite some time.
HexDecOctBin 1 days ago [-]
Yeah, but then I'll have to deal with Embarcadero.
vintagedave 1 days ago [-]
Yes - OP, you can do this via inline vars and consts:
begin
var foo : string := 'hello';
const c : integer = 5;
var bar := GetBar(); // type inference even
// and in blocks:
for var i := low(x) to high(x) do...
end;
tomekw 1 days ago [-]
That’s so great! Thank you!
I wish something like this existed for Ada :)
anthk 22 hours ago [-]
Will you port it to 32 bit? There's already a QBE port for it.
However, when I checked who the author is, I found he is is Graeme Geldenhuys, the author of the fpGUI library [1]. He surely has a lot of experience with FreePascal and the Pascal language, and in these years he has proven to be a committed worker (fpGUI exists since 2010!). So, this project seems to start on good grounds!
I really hope it will gain traction, as I have often wondered myself why somebody would not create a “clean” Pascal compiler from scratch with no legacy cruft and good defaults (e.g., UTF-8 strings, inline variable declaration).
[1]: https://fpgui.sourceforge.net/
This part isn’t true, for many years now we’ve also had Oxygene - https://www.remobjects.com/elements/oxygene/ (also proprietary)
What it lacked was a modern compiler and stack. There is FreePascal for sure, and Lazarus is impressive, but it for sure has its baggage.
I'd love to hear more about how you're using Delphi and what it excels at, compared to current web and native software stacks.
But interfaces as a concept don't require the COM backend. If you want your code to be cleanly separated, but don't want to split ownership/management models* (create/free vs ARC), and have no need for an interface and type identity to be managed outside your code and process (ie no COM), then interfaces that are not tied to ARC, and not tied to COM, give the clean code benefit without the baggage.
[*] People work around this by implementing interfaces from a base class with no-op AddRef/Release methods. But this kinda shows the problem: why is that necessary?
I work with Oxygene which is another modern Pascal -- quite a few new Pascals have popped up recently, I get the sense there's a real desire for something new! Our interfaces can be 'clean' and we support soft interfaces, too.
My real wish for Pascal interfaces is that they are pure. Some of that is not bringing in COM stuff (including recounting) because I think memory management is or should be different to interface-based clean coding. Another: In Delphi if you define a property in an interface, you have to bring in the getter and setter too. And that makes them implicitly public / visible (even if the implementing class declares them as private.) And they must be methods, there’s no way to say “read, but I don’t care how” (where Delphi can normally read fields too.) In other words, the semantic of “I want a property with read access” causes the interface contract to define the implementation, including making public the normally private / internal backing.
Whereas what I really want is to declare “property Foo: Integer read;” and the interface requires that is satisfied, but not how. In other words, interfaces are pure - they don’t bring in extra baggage. You can do that in Oxygene.
However my question was mostly with the objection against having a GUID, and how Supports() is solved without said GUID, especially since Delphi interfaces doesn't require a GUID in the first place.
But within one app, ie not crossing boundaries, perhaps their object model's vtable carries references to the interfaces, so casting of any sort to/from object-interface and interface-to-interface would work, including Supports?
Only downside is Windows support.
I wrote one major project in UCSD Pascal on Apple II 45 years ago: my Honnibo Warrior Go Playing program. For its time, a fantastic dev environment.
I wish something like this existed for Ada :)
https://jxself.org/git/supernova.git
https://jxself.org/git/beyond-the-titanic.git